@PowerMod ( BASE ; EXPONENT ; MODULUS ; RESULT )

Up to 1024-bit RSA encryption

Average rating: 4.3 (47 votes) Log in to vote

Alex Zueiv - Show more from this author
Tashkent
https://github.com/zueiv

Sample input:

@PowerMod ( Code ( "Hello World!" ) ; $e ; $m ; 1 )

Sample output:

3600431839661360632607458827868123012241176246314861
5001062969023131412752470851607786818661789896018630
9533546313391435051978469769061053779545444886749070
4692956709032729692485156613179719419164512411955252
7289346114312754672849802286764876603423866147190586
958152535210938319884278010474079360089035229525

Function definition: (Copy & paste into FileMaker's Edit Custom Function window)

// @PowerMod ( BASE ; EXPONENT ; MODULUS ; RESULT )
// 2012-09-17 Alexander Zueiv
// The parameter RESULT must be set to 1 at initial call
// Binary length of the BASE must be ≤ Lg ( MODULUS )

If ( EXPONENT ; 

@PowerMod ( 
	Mod ( BASE * BASE ; MODULUS ) ; 
	Div ( EXPONENT ; 2 ) ; 
	MODULUS ; 
	If ( Mod ( EXPONENT ; 2 ) ; 
		Mod ( RESULT * BASE ; MODULUS ) ; 
		RESULT 
	) 
) ; 

RESULT 

)

/******************************************************************************************

-- This FMP Custom Function is based on:
-- http://en.wikipedia.org/wiki/Modular_exponentiation#Right-to-left_binary_method

function modular_pow(base, exponent, modulus)
    result := 1
    while exponent > 0
        if (exponent mod 2 == 1):
           result := (result * base) mod modulus
        exponent := exponent >> 1
        base = (base * base) mod modulus
    return result

-- To test the function, evaluate the following calculation:

@PowerMod ( 4 ; 13 ; 497 ; 1 ) = Mod ( 4^13 ; 497 ) // = 445

*******************************************************************************************

-- If you don't have Advanced version of FMP, use the following Script:

Set Variable [ $BASE; Value: 4 ]
Set Variable [ $EXPONENT; Value: 13 ]
Set Variable [ $MODULUS; Value: 497 ]
#
Set Variable [ $RESULT; Value: 1 ]
Loop
	Exit Loop If [ $EXPONENT ≤ 0 ]
	If [ Mod ( $EXPONENT ;  2 ) ]
		Set Variable [ $RESULT; Value: Mod ( $RESULT * $BASE ; $MODULUS ) ]
	End If
	Set Variable [ $EXPONENT; Value: Div ( $EXPONENT ; 2 ) ]
	Set Variable [ $BASE; Value: Mod ( $BASE * $BASE ; $MODULUS ) ]
End Loop
#
Show Custom Dialog [ Message: $RESULT // = 445 ]

*******************************************************************************************

-- http://en.wikipedia.org/wiki/RSA_(algorithm)#A_working_example
-- To make sure that it works for RSA encryption, evaluate the following calculation:

Let ( [ 
	n = 3233 ; 
	e = 17 ; 
	d = 2753 
] ; 
	@PowerMod ( 65 ; e ; n ; 1 ) = 2790 and 
	@PowerMod ( 2790 ; d ; n ; 1 ) = 65 
)

*******************************************************************************************

-- To try a real RSA key-pair you may need to convert them from Hexadecimal notation system
-- The following FMP Custom Function can do the job:

// @DecFromHex ( HEX )

Let ( [ i = $i ; 

DECS = Substitute ( Filter ( Lower ( HEX ) ; "0123456789abcdef" ) ; 
	[ "0" ; "0¶" ] ; [ "1" ; "1¶" ] ; [ "2" ; "2¶" ] ; [ "3" ; "3¶" ] ; [ "4" ; "4¶" ] ; [ "5" ; "5¶" ] ; [ "6" ; "6¶" ] ; [ "7" ; "7¶" ] ; 
	[ "8" ; "8¶" ] ; [ "9" ; "9¶" ] ; [ "a" ; "10¶" ] ; [ "b" ; "11¶" ] ; [ "c" ; "12¶" ] ; [ "d" ; "13¶" ] ; [ "e" ; "14¶" ] ; [ "f" ; "15¶" ] 
) ; 

RESULT = Evaluate ( "let($i=" & ValueCount ( DECS ) & ";¶" & Substitute ( DECS ; ¶ ; "*16^let($i=$i-1;$i)+¶" ) & "0)" ) ; 

$i = i ] ; RESULT )

*******************************************************************************************

-- http://en.wikibooks.org/wiki/Transwiki:Generate_a_keypair_using_OpenSSL
-- Generate an RSA key-pair with the following commands (in Cygwin or Terminal.app):

openssl genrsa -out private_key.pem 1024
openssl rsa -text -in private_key.pem

-- Copy and paste the output into the following Let statement:

Let ( [ 

// Private-Key: (1024 bit)

modulus = @DecFromHex ( "
    00:c2:40:26:fb:bd:9a:b5:ac:86:12:68:87:b7:23:
    b6:a1:52:70:09:b2:ef:9f:d1:75:fc:76:30:6a:29:
    d0:33:25:a2:a1:e6:f8:58:61:22:10:96:ab:11:7c:
    13:51:50:43:9f:bf:05:ee:a0:5e:09:44:15:b8:c3:
    4b:07:8c:35:2f:7f:0a:bb:e4:4b:f1:26:ff:9c:2b:
    51:ec:12:0c:ad:c4:9c:1b:2b:b7:3a:8d:90:66:fe:
    b2:17:d1:15:dc:31:ac:da:f8:57:61:f7:d3:39:b0:
    07:cf:a7:31:50:eb:df:61:4e:c9:b6:73:8a:fc:b0:
    e0:ba:21:0e:07:fa:37:0c:b1" ) ; // -- n

publicExponent = 65537 ; // (0x10001) -- e

privateExponent = @DecFromHex ( "
    75:4f:be:fb:4b:7f:92:76:35:a6:0a:60:e3:f6:7a:
    86:24:be:2a:ed:58:8f:e1:34:eb:1a:09:95:23:d9:
    6b:fa:2f:a4:ad:53:90:34:61:19:39:94:e8:83:51:
    3b:4b:48:fb:c1:a6:78:7d:7b:2d:07:64:42:e8:16:
    78:e1:71:00:47:5b:03:e6:29:7d:26:8a:2c:f0:ae:
    a8:16:15:0c:3a:03:d2:96:b6:30:66:2d:87:f0:81:
    0d:d5:75:bf:7f:ab:75:89:25:c9:01:b3:ac:81:0a:
    73:c5:1e:02:49:62:a7:ca:02:eb:2a:8f:34:3d:84:
    15:eb:8f:e5:be:50:4c:cd" ) ; // -- d

MESSAGE = Code ( "Hello World!" ) ; // -- m
ENCRYPTED = @PowerMod ( MESSAGE ; publicExponent ; modulus ; 1 ) ; // -- c
DECRYPTED = @PowerMod ( ENCRYPTED ; privateExponent ; modulus ; 1 ) // -- m

] ; List ( 

	MESSAGE ; 
	ENCRYPTED ; 
	Char ( DECRYPTED ) 
) )

*******************************************************************************************

-- This function is limited by FMP math engine (400 digits): Lg ( 10^400 ) = 1328 bits
-- But using it with such a large key-pair takes unbelievable huge of time
-- Note for myself: Don't even try that anymore!.. :-)

-- Full encryption/decryption cycle with 1024-bit key-pair takes a few seconds

*******************************************************************************************

-- http://en.wikipedia.org/wiki/RSA_(algorithm)#Security_and_practical_considerations
-- An attacker can compute the secret exponent (d) from a public key-pair (n,e)
-- To prevent this, store the both keys (n & d) in a secure place of your software

-- http://en.wikipedia.org/wiki/RSA_(algorithm)#Padding_schemes
-- For better security, apply appropriated padding scheme prior to RSA encryption

******************************************************************************************/

This function allows to use 1024-bit RSA encryption in FMP.
The function itself is only a few lines long, but you should
better copy it with the whole comments that follow. They
are full of descriptions, links, and examples. Their size does
not affect the speed.

Comments

		RR, Chile Sep 24, 2012
grandiose, ...we have the decryption ? regards

		Rob, Monk Media Nov 16, 2016
Terrific! Thank you Alex!

Note: these functions are not guaranteed or supported by BrianDunning.com. Please contact the individual developer with any questions or problems.

@PowerMod ( BASE ; EXPONENT ; MODULUS ; RESULT )

Comments

Support this website.

Support this website.