For decryption, the same process is applied, except that the sub-keys Pi must be supplied in reverse order.

The nature of
the Feistel network ensures that every half is swapped for the next round (except, here, for the last two sub-keys P17
and P18)

Code: blowFish.py

p=[
0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,
0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89,
0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917,
0x9216D5D9, 0x8979FB1B
]

s=[
[
0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7,
0xB8E1AFED, 0x6A267E96, 0xBA7C9045, 0xF12C7F99,
0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16,
0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E,
0x0D95748F, 0x728EB658, 0x718BCD58, 0x82154AEE,
0x7B54A41D, 0xC25A59B5, 0x9C30D539, 0x2AF26013,
0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF,
0x8E79DCB0, 0x603A180E, 0x6C9E0E8B, 0xB01E8A3E,
0xD71577C1, 0xBD314B27, 0x78AF2FDA, 0x55605C60,
0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440,
0x55CA396A, 0x2AAB10B6, 0xB4CC5C34, 0x1141E8CE,
0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A,
0x2BA9C55D, 0x741831F6, 0xCE5C3E16, 0x9B87931E,
0xAFD6BA33, 0x6C24CF5C, 0x7A325381, 0x28958677,
0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193,
0x61D809CC, 0xFB21A991, 0x487CAC60, 0x5DEC8032,
0xEF845D5D, 0xE98575B1, 0xDC262302, 0xEB651B88,
0x23893E81, 0xD396ACC5, 0x0F6D6FF3, 0x83F44239,
0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E,
0x21C66842, 0xF6E96C9A, 0x670C9C61, 0xABD388F0,
0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3,
0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98,
0xA1F1651D, 0x39AF0176, 0x66CA593E, 0x82430E88,
0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE,
0xE06F75D8, 0x85C12073, 0x401A449F, 0x56C16AA6,
0x4ED3AA62, 0x363F7706, 0x1BFEDF72, 0x429B023D,
0x37D0D724, 0xD00A1248, 0xDB0FEAD3, 0x49F1C09B,
0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7,
0xE3FE501A, 0xB6794C3B, 0x976CE0BD, 0x04C006BA,
0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2, 0x196A2463,
0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F,
0x6DFC511F, 0x9B30952C, 0xCC814544, 0xAF5EBD09,
0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3,
0xC0CBA857, 0x45C8740F, 0xD20B5F39, 0xB9D3FBDB,
0x5579C0BD, 0x1A60320A, 0xD6A100C6, 0x402C7279,
0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8,
 0x3C7516DF, 0xFD616B15, 0x2F501EC8, 0xAD0552AB,
0x323DB5FA, 0xFD238760, 0x53317B48, 0x3E00DF82,
0x9E5C57BB, 0xCA6F8CA0, 0x1A87562E, 0xDF1769DB,
0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573,
0x695B27B0, 0xBBCA58C8, 0xE1FFA35D, 0xB8F011A0,
0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B,
0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790,
0xE1DDF2DA, 0xA4CB7E33, 0x62FB1341, 0xCEE4C6E8,
0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4,
0x95DBDA4D, 0xAE909198, 0xEAAD8E71, 0x6B93D5A0,
0xD08ED1D0, 0xAFC725E0, 0x8E3C5B2F, 0x8E7594B7,
0x8FF6E2FB, 0xF2122B64, 0x8888B812, 0x900DF01C,
0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD,
0x2F2F2218, 0xBE0E1777, 0xEA752DFE, 0x8B021FA1,
0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6, 0xCE89E299,
0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9,
0x165FA266, 0x80957705, 0x93CC7314, 0x211A1477,
0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF,
0xEBCDAF0C, 0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49,
0x00250E2D, 0x2071B35E, 0x226800BB, 0x57B8E0AF,
0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA,
0x78C14389, 0xD95A537F, 0x207D5BA2, 0x02E5B9C5,
0x83260376, 0x6295CFA9, 0x11C81968, 0x4E734A41,
0xB3472DCA, 0x7B14A94A, 0x1B510052, 0x9A532915,
0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400,
0x08BA6FB5, 0x571BE91F, 0xF296EC6B, 0x2A0DD915,
0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664,
0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A
],
[
0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623,
0xAD6EA6B0, 0x49A7DF7D, 0x9CEE60B8, 0x8FEDB266,
0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1,
0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E,
0x3F54989A, 0x5B429D65, 0x6B8FE4D6, 0x99F73FD6,
0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1,
0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E,
0x09686B3F, 0x3EBAEFC9, 0x3C971814, 0x6B6A70A1,
0x687F3584, 0x52A0E286, 0xB79C5305, 0xAA500737,
0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8,
0xB03ADA37, 0xF0500C0D, 0xF01C1F04, 0x0200B3FF,
0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD,
0xD19113F9, 0x7CA92FF6, 0x94324773, 0x22F54701,
0x3AE5E581, 0x37C2DADC, 0xC8B57634, 0x9AF3DDA7,
0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41,
0xE238CD99, 0x3BEA0E2F, 0x3280BBA1, 0x183EB331,
0x4E548B38, 0x4F6DB908, 0x6F420D03, 0xF60A04BF,
0x2CB81290, 0x24977C79, 0x5679B072, 0xBCAF89AF,
0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E,
0x5512721F, 0x2E6B7124, 0x501ADDE6, 0x9F84CD87,
0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C,
 0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2,
0xEF1C1847, 0x3215D908, 0xDD433B37, 0x24C2BA16,
0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD,
0x71DFF89E, 0x10314E55, 0x81AC77D6, 0x5F11199B,
0x043556F1, 0xD7A3C76B, 0x3C11183B, 0x5924A509,
0xF28FE6ED, 0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E,
0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3,
0x771FE71C, 0x4E3D06FA, 0x2965DCB9, 0x99E71D0F,
0x803E89D6, 0x5266C825, 0x2E4CC978, 0x9C10B36A,
0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4,
0xF2F74EA7, 0x361D2B3D, 0x1939260F, 0x19C27960,
0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66,
0xE3BC4595, 0xA67BC883, 0xB17F37D1, 0x018CFF28,
0xC332DDEF, 0xBE6C5AA5, 0x65582185, 0x68AB9802,
0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84,
0x1521B628, 0x29076170, 0xECDD4775, 0x619F1510,
0x13CCA830, 0xEB61BD96, 0x0334FE1E, 0xAA0363CF,
0xB5735C90, 0x4C70A239, 0xD59E9E0B, 0xCBAADE14,
0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E,
0x648B1EAF, 0x19BDF0CA, 0xA02369B9, 0x655ABB50,
0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7,
0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8,
0xF837889A, 0x97E32D77, 0x11ED935F, 0x16681281,
0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99,
0x57F584A5, 0x1B227263, 0x9B83C3FF, 0x1AC24696,
0xCDB30AEB, 0x532E3054, 0x8FD948E4, 0x6DBC3128,
0x58EBF2EF, 0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73,
0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0,
0x45EEE2B6, 0xA3AAABEA, 0xDB6C4F15, 0xFACB4FD0,
0xC742F442, 0xEF6ABBB5, 0x654F3B1D, 0x41CD2105,
0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250,
0xCF62A1F2, 0x5B8D2646, 0xFC8883A0, 0xC1C7B6A3,
0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285,
0x095BBF00, 0xAD19489D, 0x1462B174, 0x23820E00,
0x58428D2A, 0x0C55F5EA, 0x1DADF43E, 0x233F7061,
0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB,
0x7CDE3759, 0xCBEE7460, 0x4085F2A7, 0xCE77326E,
0xA6078084, 0x19F8509E, 0xE8EFD855, 0x61D99735,
0xA969A7AA, 0xC50C06C2, 0x5A04ABFC, 0x800BCADC,
0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9,
0xDB73DBD3, 0x105588CD, 0x675FDA79, 0xE3674340,
0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20,
0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7
],
[
0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934,
0x411520F7, 0x7602D4F7, 0xBCF46B2E, 0xD4A20068,
0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF,
0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840,
0x4D95FC1D, 0x96B591AF, 0x70F4DDD3, 0x66A02F45,
0xBFBC09EC, 0x03BD9785, 0x7FAC6DD0, 0x31CB8504,
0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A,
0x28507825, 0x530429F4, 0x0A2C86DA, 0xE9B66DFB,
0x68DC1462, 0xD7486900, 0x680EC0A4, 0x27A18DEE,
0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6,
0xAACE1E7C, 0xD3375FEC, 0xCE78A399, 0x406B2A42,
0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B,
0x1DC9FAF7, 0x4B6D1856, 0x26A36631, 0xEAE397B2,
0x3A6EFA74, 0xDD5B4332, 0x6841E7F7, 0xCA7820FB,
0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527,
0x55533A3A, 0x20838D87, 0xFE6BA9B7, 0xD096954B,
0x55A867BC, 0xA1159A58, 0xCCA92963, 0x99E1DB33,
0xA62A4A56, 0x3F3125F9, 0x5EF47E1C, 0x9029317C,
0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3,
0x95C11548, 0xE4C66D22, 0x48C1133F, 0xC70F86DC,
0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17,
0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564,
0x257B7834, 0x602A9C60, 0xDFF8E8A3, 0x1F636C1B,
0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115,
0x6B2395E0, 0x333E92E1, 0x3B240B62, 0xEEBEB922,
0x85B2A20E, 0xE6BA0D99, 0xDE720C8C, 0x2DA2F728,
0xD0127845, 0x95B794FD, 0x647D0862, 0xE7CCF5F0,
0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E,
0x0A476341, 0x992EFF74, 0x3A6F6EAB, 0xF4F8FD37,
0xA812DC60, 0xA1EBDDF8, 0x991BE14C, 0xDB6E6B0D,
0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804,
0xF1290DC7, 0xCC00FFA3, 0xB5390F92, 0x690FED0B,
0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3,
0xBB132F88, 0x515BAD24, 0x7B9479BF, 0x763BD6EB,
0x37392EB3, 0xCC115979, 0x8026E297, 0xF42E312D,
0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C,
0x6A124237, 0xB79251E7, 0x06A1BBE6, 0x4BFB6350,
0x1A6B1018, 0x11CAEDFA, 0x3D25BDD8, 0xE2E1C3C9,
0x44421659, 0x0A121386, 0xD90CEC6E, 0xD5ABEA2A,
0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE,
0x9DBC8057, 0xF0F7C086, 0x60787BF8, 0x6003604D,
0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC,
0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F,
0x77A057BE, 0xBDE8AE24, 0x55464299, 0xBF582E61,
0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2,
0x5366F9C3, 0xC8B38E74, 0xB475F255, 0x46FCD9B9,
0x7AEB2661, 0x8B1DDF84, 0x846A0E79, 0x915F95E2,
0x466E598E, 0x20B45770, 0x8CD55591, 0xC902DE4C,
0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E,
0xB77F19B6, 0xE0A9DC09, 0x662D09A1, 0xC4324633,
0xE85A1F02, 0x09F0BE8C, 0x4A99A025, 0x1D6EFE10,
0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169,
0xDCB7DA83, 0x573906FE, 0xA1E2CE9B, 0x4FCD7F52,
0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027,
0x9AF88C27, 0x773F8641, 0xC3604C06, 0x61A806B5,
0xF0177A28, 0xC0F586E0, 0x006058AA, 0x30DC7D62,
0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634,
 0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1, 0xCE591D76,
0x6F05E409, 0x4B7C0188, 0x39720A3D, 0x7C927C24,
0x86E3725F, 0x724D9DB9, 0x1AC15BB4, 0xD39EB8FC,
0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4,
0x1E50EF5E, 0xB161E6F8, 0xA28514D9, 0x6C51133C,
0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837,
0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0
],
[
0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B,
0x5CB0679E, 0x4FA33742, 0xD3822740, 0x99BC9BBE,
0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B,
0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4,
0x5748AB2F, 0xBC946E79, 0xC6A376D2, 0x6549C2C8,
0x530FF8EE, 0x468DDE7D, 0xD5730A1D, 0x4CD04DC6,
0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304,
0xA1FAD5F0, 0x6A2D519A, 0x63EF8CE2, 0x9A86EE22,
0xC089C2B8, 0x43242EF6, 0xA51E03AA, 0x9CF2D0A4,
0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6,
0x2826A2F9, 0xA73A3AE1, 0x4BA99586, 0xEF5562E9,
0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59,
0x80E4A915, 0x87B08601, 0x9B09E6AD, 0x3B3EE593,
0xE990FD5A, 0x9E34D797, 0x2CF0B7D9, 0x022B8B51,
0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28,
0x1F9F25CF, 0xADF2B89B, 0x5AD6B472, 0x5A88F54C,
0xE029AC71, 0xE019A5E6, 0x47B0ACFD, 0xED93FA9B,
0xE8D3C48D, 0x283B57CC, 0xF8D56629, 0x79132E28,
0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C,
0x15056DD4, 0x88F46DBA, 0x03A16125, 0x0564F0BD,
0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A,
0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319,
0x7533D928, 0xB155FDF5, 0x03563482, 0x8ABA3CBB,
0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F,
0x4DE81751, 0x3830DC8E, 0x379D5862, 0x9320F991,
0xEA7A90C2, 0xFB3E7BCE, 0x5121CE64, 0x774FBE32,
0xA8B6E37E, 0xC3293D46, 0x48DE5369, 0x6413E680,
0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166,
0xB39A460A, 0x6445C0DD, 0x586CDECF, 0x1C20C8AE,
0x5BBEF7DD, 0x1B588D40, 0xCCD2017F, 0x6BB4E3BB,
0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5,
0x72EACEA8, 0xFA6484BB, 0x8D6612AE, 0xBF3C6F47,
0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370,
0x740E0D8D, 0xE75B1357, 0xF8721671, 0xAF537D5D,
0x4040CB08, 0x4EB4E2CC, 0x34D2466A, 0x0115AF84,
0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048,
0x6F3F3B82, 0x3520AB82, 0x011A1D4B, 0x277227F8,
0x611560B1, 0xE7933FDC, 0xBB3A792B, 0x344525BD,
0xA08839E1, 0x51CE794B, 0x2F32C9B7, 0xA01FBAC9,
0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7,
0x1A908749, 0xD44FBD9A, 0xD0DADECB, 0xD50ADA38,
0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F,
 0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C,
0xBF97222C, 0x15E6FC2A, 0x0F91FC71, 0x9B941525,
0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1,
0xB6C1075E, 0xE3056A0C, 0x10D25065, 0xCB03A442,
0xE0EC6E0E, 0x1698DB3B, 0x4C98A0BE, 0x3278E964,
0x9F1F9532, 0xE0D392DF, 0xD3A0342B, 0x8971F21E,
0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8,
0xDF359F8D, 0x9B992F2E, 0xE60B6F47, 0x0FE3F11D,
0xE54CDA54, 0x1EDAD891, 0xCE6279CF, 0xCD3E7E6F,
0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299,
0xF523F357, 0xA6327623, 0x93A83531, 0x56CCCD02,
0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC,
0xDE966292, 0x81B949D0, 0x4C50901B, 0x71C65614,
0xE6C6C7BD, 0x327A140A, 0x45E1D006, 0xC3F27B9A,
0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6,
0x71126905, 0xB2040222, 0xB6CBCF7C, 0xCD769C2B,
0x53113EC0, 0x1640E3D3, 0x38ABBD60, 0x2547ADF0,
0xBA38209C, 0xF746CE76, 0x77AFA1C5, 0x20756060,
0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E,
0x1948C25C, 0x02FB8A8C, 0x01C36AE4, 0xD6EBE1F9,
0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F,
0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6
]
]

key = [0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623,

0xAD6EA6B0, 0x49A7DF7D, 0x9CEE60B8, 0x8FEDB266,
0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1,
0x193602A5, 0x75094C29]

p_new = p.copy()

def swap(a, b):

temp = a
a=b
b = temp
return a, b

def driver():
for i in range(0, 18):
p[i] = p[i] ^ key[i % 14]
k=0
data = 0
for i in range(0, 9):
temp = encryption(data)
p[k] = temp >> 32
k += 1
p[k] = temp & 0xffffffff
 k += 1
data = temp
encrypt_data = int(input("Enter data to encrypt: "))
encrypted_data = encryption(encrypt_data)
print("Encrypted data : ", encrypted_data)
decrypted_data = decryption(encrypted_data)
print("Decrypted data : ", decrypted_data)

def encryption(data):
L = data >> 32
R = data & 0xffffffff
for i in range(0, 16):
L = p[i] ^ L
L1 = func(L)
R = R ^ func(L1)
L, R = swap(L, R)
L, R = swap(L, R)
L = L ^ p[17]
R = R ^ p[16]
encrypted = (L << 32) ^ R
return encrypted

def func(L):
temp = s[0][L >> 24]
temp = (temp + s[1][L >> 16 & 0xff]) % 2 ** 32
temp = temp ^ s[2][L >> 8 & 0xff]
temp = (temp + s[3][L & 0xff]) % 2 ** 32
return temp

def decryption(data):
L = data >> 32
R = data & 0xffffffff
for i in range(17, 1, -1):
L = p[i] ^ L
L1 = func(L)
R = R ^ func(L1)
L, R = swap(L, R)
L, R = swap(L, R)
L = L ^ p[0]
R = R ^ p[1]
decrypted_data1 = (L << 32) ^ R
return decrypted_data1

driver()
Output:

2. Write an algorithm for RC4, RC5, RC6 and implement a code through Python
Rc4 algorithm:
Code:
def key_scheduling(key):
sched = [i for i in range(0, 256)]

i=0
for j in range(0, 256):
i = (i + sched[j] + key[j % len(key)]) % 256

tmp = sched[j]
sched[j] = sched[i]
sched[i] = tmp

return sched

def stream_generation(sched):
stream = []
i=0
j=0
while True:
i = (1 + i) % 256
j = (sched[i] + j) % 256

tmp = sched[j]
sched[j] = sched[i]
 sched[i] = tmp

yield sched[(sched[i] + sched[j]) % 256]

def encrypt(text, key):

text = [ord(char) for char in text]
key = [ord(char) for char in key]

sched = key_scheduling(key)
key_stream = stream_generation(sched)

ciphertext = ''
for char in text:
enc = str(hex(char ^ next(key_stream))).upper()
ciphertext += (enc)

return ciphertext

def decrypt(ciphertext, key):

ciphertext = ciphertext.split('0X')[1:]
ciphertext = [int('0x' + c.lower(), 0) for c in ciphertext]
key = [ord(char) for char in key]

sched = key_scheduling(key)
key_stream = stream_generation(sched)

plaintext = ''
for char in ciphertext:
dec = str(chr(char ^ next(key_stream)))
plaintext += dec

return plaintext

if __name__ == '__main__':
while (True):
ed = input('Enter E for Encrypt, or D for Decrypt and Q for Quit: ').upper()
if ed=='Q':
break;
if ed == 'E':
plaintext = input('Enter your plaintext: ')
key = input('Enter your secret key: ')
result = encrypt(plaintext, key)
print('Result: ')
print(result)
elif ed == 'D':
ciphertext = input('Enter your ciphertext: ')
 key = input('Enter your secret key: ')
result = decrypt(ciphertext, key)
print('Result: ')
print(result)
else:
print('Error in input - try again.')

Output:

Rc5 algorithms

Code:
import math

def _rotate_left(val, r_bits, max_bits):

v1 = (val << r_bits % max_bits) & (2 ** max_bits - 1)
v2 = ((val & (2 ** max_bits - 1)) >> (max_bits - (r_bits % max_bits)))
return v1 | v2

def _rotate_right(val, r_bits, max_bits):

v1 = ((val & (2 ** max_bits - 1)) >> r_bits % max_bits)
v2 = (val << (max_bits - (r_bits % max_bits)) & (2 ** max_bits - 1))

return v1 | v2

def _expand_key(key, wordsize, rounds):

# Pads _key so that it is aligned with the word size, then splits it into words
def _align_key(key, align_val):
while len(key) % (align_val):
key += b'\x00' # Add 0 bytes until the _key length is aligned to the block size

L = []
for i in range(0, len(key), align_val):
 L.append(int.from_bytes(key[i:i + align_val], byteorder='little'))

return L

# generation function of the constants for the extend step

def _const(w):
if w == 16:
return (0xB7E1, 0x9E37) # Returns the value of P and Q
elif w == 32:
return (0xB7E15163, 0x9E3779B9)
elif w == 64:
return (0xB7E151628AED2A6B, 0x9E3779B97F4A7C15)

# Generate pseudo-random list S

def _extend_key(w, r):
P, Q = _const(w)
S = [P]
t = 2 * (r + 1)
for i in range(1, t):
S.append((S[i - 1] + Q) % 2 ** w)

return S

def _mix(L, S, r, w, c):

t = 2 * (r + 1)
m = max(c, t)
A=B=i=j=0

for k in range(3 * m):

A = S[i] = _rotate_left(S[i] + A + B, 3, w)
B = L[j] = _rotate_left(L[j] + A + B, A + B, w)

i = (i + 1) % t
j = (j + 1) % c

return S

aligned = _align_key(key, wordsize // 8)

extended = _extend_key(wordsize, rounds)

S = _mix(aligned, extended, rounds, wordsize, len(aligned))

return S

def rc5_encrypt(data, expanded_key, blocksize, rounds):

w = blocksize // 2
b = blocksize // 8
mod = 2 ** w
 A = int.from_bytes(data[:b // 2], byteorder='little')
B = int.from_bytes(data[b // 2:], byteorder='little')

A = (A + expanded_key[0]) % mod
B = (B + expanded_key[1]) % mod

for i in range(1, rounds + 1):

A = (_rotate_left((A ^ B), B, w) + expanded_key[2 * i]) % mod
B = (_rotate_left((A ^ B), A, w) + expanded_key[2 * i + 1]) % mod

res = A.to_bytes(b // 2, byteorder='little') + B.to_bytes(b // 2, byteorder='little')

return res

def rc5_decrypt(data, expanded_key, blocksize, rounds):

w = blocksize // 2
b = blocksize // 8
mod = 2 ** w

A = int.from_bytes(data[:b // 2], byteorder='little')

B = int.from_bytes(data[b // 2:], byteorder='little')

for i in range(rounds, 0, -1):

B = _rotate_right(B - expanded_key[2 * i + 1], A, w) ^ A
A = _rotate_right((A - expanded_key[2 * i]), B, w) ^ B

B = (B - expanded_key[1]) % mod
A = (A - expanded_key[0]) % mod

res = A.to_bytes(b // 2, byteorder='little') + B.to_bytes(b // 2, byteorder='little')

return res

if __name__ == '__main__':
while (True):
ed = input('Enter E for Encrypt, or D for Decrypt and Q for Quit: ').upper()
if ed=='Q':
break;
if ed == 'E':
plaintext = input('Enter your plaintext: ')
key = input('Enter your secret key: ')
result = rc5_encrypt(plaintext,key,32,12)
print('Result: ')
print(result)
elif ed == 'D':
ciphertext = input('Enter your ciphertext: ')
key = input('Enter your secret key: ')
result = rc5_encrypt(ciphertext, key,32,12)
print('Result: ')
print(result)
 else:
print('Error in input - try again.')

Output:

Rc6 Algorithms:

Code:
import math
import sys

#rotate right input x, by n bits

def ROR(x, n, bits = 32):
mask = (2**n) - 1
mask_bits = x & mask
return (x >> n) | (mask_bits << (bits - n))

#rotate left input x, by n bits

def ROL(x, n, bits = 32):
 return ROR(x, bits - n,bits)

#convert input sentence into blocks of binary

#creates 4 blocks of binary each of 32 bits.
def blockConverter(sentence):
encoded = []
res = ""
for i in range(0,len(sentence)):
if i%4==0 and i!=0 :
encoded.append(res)
res = ""
temp = bin(ord(sentence[i]))[2:]
if len(temp) <8:
temp = "0"*(8-len(temp)) + temp
res = res + temp
encoded.append(res)
return encoded

def deBlocker(blocks):
s = ""
for ele in blocks:
temp =bin(ele)[2:]
if len(temp) <32:
temp = "0"*(32-len(temp)) + temp
for i in range(0,4):
s=s+chr(int(temp[i*8:(i+1)*8],2))
return s
#generate key s[0... 2r+3] from given input string userkey
def generateKey(userkey):
r=12
w=32
b=len(userkey)
modulo = 2**32
s=(2*r+4)*[0]
s[0]=0xB7E15163
for i in range(1,2*r+4):
s[i]=(s[i-1]+0x9E3779B9)%(2**w)
encoded = blockConverter(userkey)
#print encoded
enlength = len(encoded)
l = enlength*[0]
for i in range(1,enlength+1):
l[enlength-i]=int(encoded[i-1],2)

v = 3*max(enlength,2*r+4)
A=B=i=j=0

for index in range(0,v):

A = s[i] = ROL((s[i] + A + B)%modulo,3,32)
B = l[j] = ROL((l[j] + A + B)%modulo,(A+B)%32,32)
i = (i + 1) % (2*r + 4)
 j = (j + 1) % enlength
return s

def encrypt(sentence,s):
encoded = blockConverter(sentence)
enlength = len(encoded)
A = int(encoded[0],2)
B = int(encoded[1],2)
C = int(encoded[2],2)
D = int(encoded[3],2)
orgi = []
orgi.append(A)
orgi.append(B)
orgi.append(C)
orgi.append(D)
r=12
w=32
modulo = 2**32
lgw = 5
B = (B + s[0])%modulo
D = (D + s[1])%modulo
for i in range(1,r+1):
t_temp = (B*(2*B + 1))%modulo
t = ROL(t_temp,lgw,32)
u_temp = (D*(2*D + 1))%modulo
u = ROL(u_temp,lgw,32)
tmod=t%32
umod=u%32
A = (ROL(A^t,umod,32) + s[2*i])%modulo
C = (ROL(C^u,tmod,32) + s[2*i+ 1])%modulo
(A, B, C, D) = (B, C, D, A)
A = (A + s[2*r + 2])%modulo
C = (C + s[2*r + 3])%modulo
cipher = []
cipher.append(A)
cipher.append(B)
cipher.append(C)
cipher.append(D)
return orgi,cipher

def decrypt(esentence,s):
encoded = blockConverter(esentence)
enlength = len(encoded)
A = int(encoded[0],2)
B = int(encoded[1],2)
C = int(encoded[2],2)
D = int(encoded[3],2)
cipher = []
cipher.append(A)
cipher.append(B)
 cipher.append(C)
cipher.append(D)
r=12
w=32
modulo = 2**32
lgw = 5
C = (C - s[2*r+3])%modulo
A = (A - s[2*r+2])%modulo
for j in range(1,r+1):
i = r+1-j
(A, B, C, D) = (D, A, B, C)
u_temp = (D*(2*D + 1))%modulo
u = ROL(u_temp,lgw,32)
t_temp = (B*(2*B + 1))%modulo
t = ROL(t_temp,lgw,32)
tmod=t%32
umod=u%32
C = (ROR((C-s[2*i+1])%modulo,tmod,32) ^u)
A = (ROR((A-s[2*i])%modulo,umod,32) ^t)
D = (D - s[1])%modulo
B = (B - s[0])%modulo
orgi = []
orgi.append(A)
orgi.append(B)
orgi.append(C)
orgi.append(D)
return cipher,orgi

def main():

key='A WORD IS A WORD'

sentence = 'I WORD IS A WORD'

sentence =sentence + " "*(16-len(sentence))

key =key + " "*(16-len(key))

key = key[:16]

print("Key:\t"+key)
s = generateKey(key)

sentence = sentence[:16]

orgi,cipher = encrypt(sentence,s)
esentence = deBlocker(cipher)
 print("Input:\t "+sentence)

print("\nOriginal String list: ",orgi)

print("Length of Input String: ",len(sentence))

print("\nEncrypted String list: ",cipher)

print("Encrypted String: " + esentence)
print("Length of Encrypted String: ",len(esentence))

cipher,orgi = decrypt(esentence,s)
sentence = deBlocker(orgi)
print("\nDecrypted:\t",sentence)

if __name__ == "__main__":
main()

Output

3. IDEAAlgorithm
3.1 . Encrypt the following message using IDEA algorithm
Message: 1111 1011 1101 1010
Key: 10101001110111110110010111000011
Procedure:
To encrypt the message using the IDEA algorithm, we need to follow the below steps:
Step 1: Divide the message into two 16-bit blocks - 1111101111011010 and
0000000000000000.
Step 2: Convert the key into 8 sub-keys of 16-bit each. To do this, we need to divide the 128-bit
key into 8 groups of 16-bit each. The sub-keys are as follows:

Step 3: Apply the encryption rounds. IDEA algorithm uses a total of 8 rounds for encryption. In
each round, we apply the following operations:

After applying all the 8 rounds, we get the following encrypted message:

3.2. Generate the key for decryption from the following encryption key. Key:
10101001110111110110010111000011
To generate the decryption key from the given encryption key in IDEA algorithm, we need to
follow the below steps:
Step 1: Divide the key into 8 sub-keys of 16-bit each. To do this, we need to divide the 128-bit
key into 8 groups of 16-bit each. The sub-keys are as follows
K1 = 1010100111011111

K2 = 0110010110000101

K3 = 1100101110000011

K4 = 0010110111001111

K5 = 0101110100110011

K6 = 1011000011111001

K7 = 0101101110010011

K8 = 1100000010110111

Step 2: Generate the decryption sub-keys by performing the inverse operations on the
encryption sub-keys. To do this, we need to perform the following steps:
1. Calculate the inverse of the second and third sub-keys using the extended Euclidean
algorithm.
2. Calculate the negation of the first, fifth, sixth, and eighth sub-keys.
3. Inverse the order of the sub-keys.
After performing the above steps, we get the following decryption sub-keys:
K1^-1 = 1010100111011111 (same as K1 for encryption)
K2^-1 = 1110100100101111
K3^-1 = 0101101010110000
K4^-1 = 1010011000000001
K5^-1 = 1011111101001011
K6^-1 = 0011110111110110
K7^-1 = 1010011000111011
K8^-1 = 0011100000101110
Therefore, the decryption key is:
1010100111011111 1110100100101111 0101101010110000 1010011000000001
1011111101001011 0011110111110110 1010011000111011 0011100000101110