diff options
Diffstat (limited to 'src')
32 files changed, 16 insertions, 1970 deletions
diff --git a/src/nvim/blowfish.c b/src/nvim/blowfish.c deleted file mode 100644 index d48724ada4..0000000000 --- a/src/nvim/blowfish.c +++ /dev/null @@ -1,622 +0,0 @@ -/* - * VIM - Vi IMproved by Bram Moolenaar - * - * Do ":help uganda" in Vim to read copying and usage conditions. - * Do ":help credits" in Vim to see a list of people who contributed. - * See README.txt for an overview of the Vim source code. - * - * Blowfish encryption for Vim; in Blowfish cipher feedback mode. - * Contributed by Mohsin Ahmed, http://www.cs.albany.edu/~mosh - * Based on http://www.schneier.com/blowfish.html by Bruce Schneier. - */ - -#include <string.h> - -#include "nvim/vim.h" -#include "nvim/blowfish.h" -#include "nvim/message.h" -#include "nvim/sha256.h" - -#define ARRAY_LENGTH(A) (sizeof(A) / sizeof(A[0])) - -#define BF_BLOCK 8 -#define BF_BLOCK_MASK 7 -#define BF_CFB_LEN (8 * (BF_BLOCK)) - -typedef union { - uint32_t ul[2]; - char_u uc[8]; -} block8; - - -static void bf_e_block(uint32_t *p_xl, uint32_t *p_xr); -static void bf_e_cblock(char_u *block); -static int bf_check_tables(uint32_t a_ipa[18], uint32_t a_sbi[4][256], - uint32_t val); -static int bf_self_test(void); - -/* Blowfish code */ -static uint32_t pax[18]; -static uint32_t ipa[18] = { - 0x243f6a88u, 0x85a308d3u, 0x13198a2eu, - 0x03707344u, 0xa4093822u, 0x299f31d0u, - 0x082efa98u, 0xec4e6c89u, 0x452821e6u, - 0x38d01377u, 0xbe5466cfu, 0x34e90c6cu, - 0xc0ac29b7u, 0xc97c50ddu, 0x3f84d5b5u, - 0xb5470917u, 0x9216d5d9u, 0x8979fb1bu -}; - -static uint32_t sbx[4][256]; -static uint32_t sbi[4][256] = { - {0xd1310ba6u, 0x98dfb5acu, 0x2ffd72dbu, 0xd01adfb7u, - 0xb8e1afedu, 0x6a267e96u, 0xba7c9045u, 0xf12c7f99u, - 0x24a19947u, 0xb3916cf7u, 0x0801f2e2u, 0x858efc16u, - 0x636920d8u, 0x71574e69u, 0xa458fea3u, 0xf4933d7eu, - 0x0d95748fu, 0x728eb658u, 0x718bcd58u, 0x82154aeeu, - 0x7b54a41du, 0xc25a59b5u, 0x9c30d539u, 0x2af26013u, - 0xc5d1b023u, 0x286085f0u, 0xca417918u, 0xb8db38efu, - 0x8e79dcb0u, 0x603a180eu, 0x6c9e0e8bu, 0xb01e8a3eu, - 0xd71577c1u, 0xbd314b27u, 0x78af2fdau, 0x55605c60u, - 0xe65525f3u, 0xaa55ab94u, 0x57489862u, 0x63e81440u, - 0x55ca396au, 0x2aab10b6u, 0xb4cc5c34u, 0x1141e8ceu, - 0xa15486afu, 0x7c72e993u, 0xb3ee1411u, 0x636fbc2au, - 0x2ba9c55du, 0x741831f6u, 0xce5c3e16u, 0x9b87931eu, - 0xafd6ba33u, 0x6c24cf5cu, 0x7a325381u, 0x28958677u, - 0x3b8f4898u, 0x6b4bb9afu, 0xc4bfe81bu, 0x66282193u, - 0x61d809ccu, 0xfb21a991u, 0x487cac60u, 0x5dec8032u, - 0xef845d5du, 0xe98575b1u, 0xdc262302u, 0xeb651b88u, - 0x23893e81u, 0xd396acc5u, 0x0f6d6ff3u, 0x83f44239u, - 0x2e0b4482u, 0xa4842004u, 0x69c8f04au, 0x9e1f9b5eu, - 0x21c66842u, 0xf6e96c9au, 0x670c9c61u, 0xabd388f0u, - 0x6a51a0d2u, 0xd8542f68u, 0x960fa728u, 0xab5133a3u, - 0x6eef0b6cu, 0x137a3be4u, 0xba3bf050u, 0x7efb2a98u, - 0xa1f1651du, 0x39af0176u, 0x66ca593eu, 0x82430e88u, - 0x8cee8619u, 0x456f9fb4u, 0x7d84a5c3u, 0x3b8b5ebeu, - 0xe06f75d8u, 0x85c12073u, 0x401a449fu, 0x56c16aa6u, - 0x4ed3aa62u, 0x363f7706u, 0x1bfedf72u, 0x429b023du, - 0x37d0d724u, 0xd00a1248u, 0xdb0fead3u, 0x49f1c09bu, - 0x075372c9u, 0x80991b7bu, 0x25d479d8u, 0xf6e8def7u, - 0xe3fe501au, 0xb6794c3bu, 0x976ce0bdu, 0x04c006bau, - 0xc1a94fb6u, 0x409f60c4u, 0x5e5c9ec2u, 0x196a2463u, - 0x68fb6fafu, 0x3e6c53b5u, 0x1339b2ebu, 0x3b52ec6fu, - 0x6dfc511fu, 0x9b30952cu, 0xcc814544u, 0xaf5ebd09u, - 0xbee3d004u, 0xde334afdu, 0x660f2807u, 0x192e4bb3u, - 0xc0cba857u, 0x45c8740fu, 0xd20b5f39u, 0xb9d3fbdbu, - 0x5579c0bdu, 0x1a60320au, 0xd6a100c6u, 0x402c7279u, - 0x679f25feu, 0xfb1fa3ccu, 0x8ea5e9f8u, 0xdb3222f8u, - 0x3c7516dfu, 0xfd616b15u, 0x2f501ec8u, 0xad0552abu, - 0x323db5fau, 0xfd238760u, 0x53317b48u, 0x3e00df82u, - 0x9e5c57bbu, 0xca6f8ca0u, 0x1a87562eu, 0xdf1769dbu, - 0xd542a8f6u, 0x287effc3u, 0xac6732c6u, 0x8c4f5573u, - 0x695b27b0u, 0xbbca58c8u, 0xe1ffa35du, 0xb8f011a0u, - 0x10fa3d98u, 0xfd2183b8u, 0x4afcb56cu, 0x2dd1d35bu, - 0x9a53e479u, 0xb6f84565u, 0xd28e49bcu, 0x4bfb9790u, - 0xe1ddf2dau, 0xa4cb7e33u, 0x62fb1341u, 0xcee4c6e8u, - 0xef20cadau, 0x36774c01u, 0xd07e9efeu, 0x2bf11fb4u, - 0x95dbda4du, 0xae909198u, 0xeaad8e71u, 0x6b93d5a0u, - 0xd08ed1d0u, 0xafc725e0u, 0x8e3c5b2fu, 0x8e7594b7u, - 0x8ff6e2fbu, 0xf2122b64u, 0x8888b812u, 0x900df01cu, - 0x4fad5ea0u, 0x688fc31cu, 0xd1cff191u, 0xb3a8c1adu, - 0x2f2f2218u, 0xbe0e1777u, 0xea752dfeu, 0x8b021fa1u, - 0xe5a0cc0fu, 0xb56f74e8u, 0x18acf3d6u, 0xce89e299u, - 0xb4a84fe0u, 0xfd13e0b7u, 0x7cc43b81u, 0xd2ada8d9u, - 0x165fa266u, 0x80957705u, 0x93cc7314u, 0x211a1477u, - 0xe6ad2065u, 0x77b5fa86u, 0xc75442f5u, 0xfb9d35cfu, - 0xebcdaf0cu, 0x7b3e89a0u, 0xd6411bd3u, 0xae1e7e49u, - 0x00250e2du, 0x2071b35eu, 0x226800bbu, 0x57b8e0afu, - 0x2464369bu, 0xf009b91eu, 0x5563911du, 0x59dfa6aau, - 0x78c14389u, 0xd95a537fu, 0x207d5ba2u, 0x02e5b9c5u, - 0x83260376u, 0x6295cfa9u, 0x11c81968u, 0x4e734a41u, - 0xb3472dcau, 0x7b14a94au, 0x1b510052u, 0x9a532915u, - 0xd60f573fu, 0xbc9bc6e4u, 0x2b60a476u, 0x81e67400u, - 0x08ba6fb5u, 0x571be91fu, 0xf296ec6bu, 0x2a0dd915u, - 0xb6636521u, 0xe7b9f9b6u, 0xff34052eu, 0xc5855664u, - 0x53b02d5du, 0xa99f8fa1u, 0x08ba4799u, 0x6e85076au}, - {0x4b7a70e9u, 0xb5b32944u, 0xdb75092eu, 0xc4192623u, - 0xad6ea6b0u, 0x49a7df7du, 0x9cee60b8u, 0x8fedb266u, - 0xecaa8c71u, 0x699a17ffu, 0x5664526cu, 0xc2b19ee1u, - 0x193602a5u, 0x75094c29u, 0xa0591340u, 0xe4183a3eu, - 0x3f54989au, 0x5b429d65u, 0x6b8fe4d6u, 0x99f73fd6u, - 0xa1d29c07u, 0xefe830f5u, 0x4d2d38e6u, 0xf0255dc1u, - 0x4cdd2086u, 0x8470eb26u, 0x6382e9c6u, 0x021ecc5eu, - 0x09686b3fu, 0x3ebaefc9u, 0x3c971814u, 0x6b6a70a1u, - 0x687f3584u, 0x52a0e286u, 0xb79c5305u, 0xaa500737u, - 0x3e07841cu, 0x7fdeae5cu, 0x8e7d44ecu, 0x5716f2b8u, - 0xb03ada37u, 0xf0500c0du, 0xf01c1f04u, 0x0200b3ffu, - 0xae0cf51au, 0x3cb574b2u, 0x25837a58u, 0xdc0921bdu, - 0xd19113f9u, 0x7ca92ff6u, 0x94324773u, 0x22f54701u, - 0x3ae5e581u, 0x37c2dadcu, 0xc8b57634u, 0x9af3dda7u, - 0xa9446146u, 0x0fd0030eu, 0xecc8c73eu, 0xa4751e41u, - 0xe238cd99u, 0x3bea0e2fu, 0x3280bba1u, 0x183eb331u, - 0x4e548b38u, 0x4f6db908u, 0x6f420d03u, 0xf60a04bfu, - 0x2cb81290u, 0x24977c79u, 0x5679b072u, 0xbcaf89afu, - 0xde9a771fu, 0xd9930810u, 0xb38bae12u, 0xdccf3f2eu, - 0x5512721fu, 0x2e6b7124u, 0x501adde6u, 0x9f84cd87u, - 0x7a584718u, 0x7408da17u, 0xbc9f9abcu, 0xe94b7d8cu, - 0xec7aec3au, 0xdb851dfau, 0x63094366u, 0xc464c3d2u, - 0xef1c1847u, 0x3215d908u, 0xdd433b37u, 0x24c2ba16u, - 0x12a14d43u, 0x2a65c451u, 0x50940002u, 0x133ae4ddu, - 0x71dff89eu, 0x10314e55u, 0x81ac77d6u, 0x5f11199bu, - 0x043556f1u, 0xd7a3c76bu, 0x3c11183bu, 0x5924a509u, - 0xf28fe6edu, 0x97f1fbfau, 0x9ebabf2cu, 0x1e153c6eu, - 0x86e34570u, 0xeae96fb1u, 0x860e5e0au, 0x5a3e2ab3u, - 0x771fe71cu, 0x4e3d06fau, 0x2965dcb9u, 0x99e71d0fu, - 0x803e89d6u, 0x5266c825u, 0x2e4cc978u, 0x9c10b36au, - 0xc6150ebau, 0x94e2ea78u, 0xa5fc3c53u, 0x1e0a2df4u, - 0xf2f74ea7u, 0x361d2b3du, 0x1939260fu, 0x19c27960u, - 0x5223a708u, 0xf71312b6u, 0xebadfe6eu, 0xeac31f66u, - 0xe3bc4595u, 0xa67bc883u, 0xb17f37d1u, 0x018cff28u, - 0xc332ddefu, 0xbe6c5aa5u, 0x65582185u, 0x68ab9802u, - 0xeecea50fu, 0xdb2f953bu, 0x2aef7dadu, 0x5b6e2f84u, - 0x1521b628u, 0x29076170u, 0xecdd4775u, 0x619f1510u, - 0x13cca830u, 0xeb61bd96u, 0x0334fe1eu, 0xaa0363cfu, - 0xb5735c90u, 0x4c70a239u, 0xd59e9e0bu, 0xcbaade14u, - 0xeecc86bcu, 0x60622ca7u, 0x9cab5cabu, 0xb2f3846eu, - 0x648b1eafu, 0x19bdf0cau, 0xa02369b9u, 0x655abb50u, - 0x40685a32u, 0x3c2ab4b3u, 0x319ee9d5u, 0xc021b8f7u, - 0x9b540b19u, 0x875fa099u, 0x95f7997eu, 0x623d7da8u, - 0xf837889au, 0x97e32d77u, 0x11ed935fu, 0x16681281u, - 0x0e358829u, 0xc7e61fd6u, 0x96dedfa1u, 0x7858ba99u, - 0x57f584a5u, 0x1b227263u, 0x9b83c3ffu, 0x1ac24696u, - 0xcdb30aebu, 0x532e3054u, 0x8fd948e4u, 0x6dbc3128u, - 0x58ebf2efu, 0x34c6ffeau, 0xfe28ed61u, 0xee7c3c73u, - 0x5d4a14d9u, 0xe864b7e3u, 0x42105d14u, 0x203e13e0u, - 0x45eee2b6u, 0xa3aaabeau, 0xdb6c4f15u, 0xfacb4fd0u, - 0xc742f442u, 0xef6abbb5u, 0x654f3b1du, 0x41cd2105u, - 0xd81e799eu, 0x86854dc7u, 0xe44b476au, 0x3d816250u, - 0xcf62a1f2u, 0x5b8d2646u, 0xfc8883a0u, 0xc1c7b6a3u, - 0x7f1524c3u, 0x69cb7492u, 0x47848a0bu, 0x5692b285u, - 0x095bbf00u, 0xad19489du, 0x1462b174u, 0x23820e00u, - 0x58428d2au, 0x0c55f5eau, 0x1dadf43eu, 0x233f7061u, - 0x3372f092u, 0x8d937e41u, 0xd65fecf1u, 0x6c223bdbu, - 0x7cde3759u, 0xcbee7460u, 0x4085f2a7u, 0xce77326eu, - 0xa6078084u, 0x19f8509eu, 0xe8efd855u, 0x61d99735u, - 0xa969a7aau, 0xc50c06c2u, 0x5a04abfcu, 0x800bcadcu, - 0x9e447a2eu, 0xc3453484u, 0xfdd56705u, 0x0e1e9ec9u, - 0xdb73dbd3u, 0x105588cdu, 0x675fda79u, 0xe3674340u, - 0xc5c43465u, 0x713e38d8u, 0x3d28f89eu, 0xf16dff20u, - 0x153e21e7u, 0x8fb03d4au, 0xe6e39f2bu, 0xdb83adf7u}, - {0xe93d5a68u, 0x948140f7u, 0xf64c261cu, 0x94692934u, - 0x411520f7u, 0x7602d4f7u, 0xbcf46b2eu, 0xd4a20068u, - 0xd4082471u, 0x3320f46au, 0x43b7d4b7u, 0x500061afu, - 0x1e39f62eu, 0x97244546u, 0x14214f74u, 0xbf8b8840u, - 0x4d95fc1du, 0x96b591afu, 0x70f4ddd3u, 0x66a02f45u, - 0xbfbc09ecu, 0x03bd9785u, 0x7fac6dd0u, 0x31cb8504u, - 0x96eb27b3u, 0x55fd3941u, 0xda2547e6u, 0xabca0a9au, - 0x28507825u, 0x530429f4u, 0x0a2c86dau, 0xe9b66dfbu, - 0x68dc1462u, 0xd7486900u, 0x680ec0a4u, 0x27a18deeu, - 0x4f3ffea2u, 0xe887ad8cu, 0xb58ce006u, 0x7af4d6b6u, - 0xaace1e7cu, 0xd3375fecu, 0xce78a399u, 0x406b2a42u, - 0x20fe9e35u, 0xd9f385b9u, 0xee39d7abu, 0x3b124e8bu, - 0x1dc9faf7u, 0x4b6d1856u, 0x26a36631u, 0xeae397b2u, - 0x3a6efa74u, 0xdd5b4332u, 0x6841e7f7u, 0xca7820fbu, - 0xfb0af54eu, 0xd8feb397u, 0x454056acu, 0xba489527u, - 0x55533a3au, 0x20838d87u, 0xfe6ba9b7u, 0xd096954bu, - 0x55a867bcu, 0xa1159a58u, 0xcca92963u, 0x99e1db33u, - 0xa62a4a56u, 0x3f3125f9u, 0x5ef47e1cu, 0x9029317cu, - 0xfdf8e802u, 0x04272f70u, 0x80bb155cu, 0x05282ce3u, - 0x95c11548u, 0xe4c66d22u, 0x48c1133fu, 0xc70f86dcu, - 0x07f9c9eeu, 0x41041f0fu, 0x404779a4u, 0x5d886e17u, - 0x325f51ebu, 0xd59bc0d1u, 0xf2bcc18fu, 0x41113564u, - 0x257b7834u, 0x602a9c60u, 0xdff8e8a3u, 0x1f636c1bu, - 0x0e12b4c2u, 0x02e1329eu, 0xaf664fd1u, 0xcad18115u, - 0x6b2395e0u, 0x333e92e1u, 0x3b240b62u, 0xeebeb922u, - 0x85b2a20eu, 0xe6ba0d99u, 0xde720c8cu, 0x2da2f728u, - 0xd0127845u, 0x95b794fdu, 0x647d0862u, 0xe7ccf5f0u, - 0x5449a36fu, 0x877d48fau, 0xc39dfd27u, 0xf33e8d1eu, - 0x0a476341u, 0x992eff74u, 0x3a6f6eabu, 0xf4f8fd37u, - 0xa812dc60u, 0xa1ebddf8u, 0x991be14cu, 0xdb6e6b0du, - 0xc67b5510u, 0x6d672c37u, 0x2765d43bu, 0xdcd0e804u, - 0xf1290dc7u, 0xcc00ffa3u, 0xb5390f92u, 0x690fed0bu, - 0x667b9ffbu, 0xcedb7d9cu, 0xa091cf0bu, 0xd9155ea3u, - 0xbb132f88u, 0x515bad24u, 0x7b9479bfu, 0x763bd6ebu, - 0x37392eb3u, 0xcc115979u, 0x8026e297u, 0xf42e312du, - 0x6842ada7u, 0xc66a2b3bu, 0x12754cccu, 0x782ef11cu, - 0x6a124237u, 0xb79251e7u, 0x06a1bbe6u, 0x4bfb6350u, - 0x1a6b1018u, 0x11caedfau, 0x3d25bdd8u, 0xe2e1c3c9u, - 0x44421659u, 0x0a121386u, 0xd90cec6eu, 0xd5abea2au, - 0x64af674eu, 0xda86a85fu, 0xbebfe988u, 0x64e4c3feu, - 0x9dbc8057u, 0xf0f7c086u, 0x60787bf8u, 0x6003604du, - 0xd1fd8346u, 0xf6381fb0u, 0x7745ae04u, 0xd736fcccu, - 0x83426b33u, 0xf01eab71u, 0xb0804187u, 0x3c005e5fu, - 0x77a057beu, 0xbde8ae24u, 0x55464299u, 0xbf582e61u, - 0x4e58f48fu, 0xf2ddfda2u, 0xf474ef38u, 0x8789bdc2u, - 0x5366f9c3u, 0xc8b38e74u, 0xb475f255u, 0x46fcd9b9u, - 0x7aeb2661u, 0x8b1ddf84u, 0x846a0e79u, 0x915f95e2u, - 0x466e598eu, 0x20b45770u, 0x8cd55591u, 0xc902de4cu, - 0xb90bace1u, 0xbb8205d0u, 0x11a86248u, 0x7574a99eu, - 0xb77f19b6u, 0xe0a9dc09u, 0x662d09a1u, 0xc4324633u, - 0xe85a1f02u, 0x09f0be8cu, 0x4a99a025u, 0x1d6efe10u, - 0x1ab93d1du, 0x0ba5a4dfu, 0xa186f20fu, 0x2868f169u, - 0xdcb7da83u, 0x573906feu, 0xa1e2ce9bu, 0x4fcd7f52u, - 0x50115e01u, 0xa70683fau, 0xa002b5c4u, 0x0de6d027u, - 0x9af88c27u, 0x773f8641u, 0xc3604c06u, 0x61a806b5u, - 0xf0177a28u, 0xc0f586e0u, 0x006058aau, 0x30dc7d62u, - 0x11e69ed7u, 0x2338ea63u, 0x53c2dd94u, 0xc2c21634u, - 0xbbcbee56u, 0x90bcb6deu, 0xebfc7da1u, 0xce591d76u, - 0x6f05e409u, 0x4b7c0188u, 0x39720a3du, 0x7c927c24u, - 0x86e3725fu, 0x724d9db9u, 0x1ac15bb4u, 0xd39eb8fcu, - 0xed545578u, 0x08fca5b5u, 0xd83d7cd3u, 0x4dad0fc4u, - 0x1e50ef5eu, 0xb161e6f8u, 0xa28514d9u, 0x6c51133cu, - 0x6fd5c7e7u, 0x56e14ec4u, 0x362abfceu, 0xddc6c837u, - 0xd79a3234u, 0x92638212u, 0x670efa8eu, 0x406000e0u}, - {0x3a39ce37u, 0xd3faf5cfu, 0xabc27737u, 0x5ac52d1bu, - 0x5cb0679eu, 0x4fa33742u, 0xd3822740u, 0x99bc9bbeu, - 0xd5118e9du, 0xbf0f7315u, 0xd62d1c7eu, 0xc700c47bu, - 0xb78c1b6bu, 0x21a19045u, 0xb26eb1beu, 0x6a366eb4u, - 0x5748ab2fu, 0xbc946e79u, 0xc6a376d2u, 0x6549c2c8u, - 0x530ff8eeu, 0x468dde7du, 0xd5730a1du, 0x4cd04dc6u, - 0x2939bbdbu, 0xa9ba4650u, 0xac9526e8u, 0xbe5ee304u, - 0xa1fad5f0u, 0x6a2d519au, 0x63ef8ce2u, 0x9a86ee22u, - 0xc089c2b8u, 0x43242ef6u, 0xa51e03aau, 0x9cf2d0a4u, - 0x83c061bau, 0x9be96a4du, 0x8fe51550u, 0xba645bd6u, - 0x2826a2f9u, 0xa73a3ae1u, 0x4ba99586u, 0xef5562e9u, - 0xc72fefd3u, 0xf752f7dau, 0x3f046f69u, 0x77fa0a59u, - 0x80e4a915u, 0x87b08601u, 0x9b09e6adu, 0x3b3ee593u, - 0xe990fd5au, 0x9e34d797u, 0x2cf0b7d9u, 0x022b8b51u, - 0x96d5ac3au, 0x017da67du, 0xd1cf3ed6u, 0x7c7d2d28u, - 0x1f9f25cfu, 0xadf2b89bu, 0x5ad6b472u, 0x5a88f54cu, - 0xe029ac71u, 0xe019a5e6u, 0x47b0acfdu, 0xed93fa9bu, - 0xe8d3c48du, 0x283b57ccu, 0xf8d56629u, 0x79132e28u, - 0x785f0191u, 0xed756055u, 0xf7960e44u, 0xe3d35e8cu, - 0x15056dd4u, 0x88f46dbau, 0x03a16125u, 0x0564f0bdu, - 0xc3eb9e15u, 0x3c9057a2u, 0x97271aecu, 0xa93a072au, - 0x1b3f6d9bu, 0x1e6321f5u, 0xf59c66fbu, 0x26dcf319u, - 0x7533d928u, 0xb155fdf5u, 0x03563482u, 0x8aba3cbbu, - 0x28517711u, 0xc20ad9f8u, 0xabcc5167u, 0xccad925fu, - 0x4de81751u, 0x3830dc8eu, 0x379d5862u, 0x9320f991u, - 0xea7a90c2u, 0xfb3e7bceu, 0x5121ce64u, 0x774fbe32u, - 0xa8b6e37eu, 0xc3293d46u, 0x48de5369u, 0x6413e680u, - 0xa2ae0810u, 0xdd6db224u, 0x69852dfdu, 0x09072166u, - 0xb39a460au, 0x6445c0ddu, 0x586cdecfu, 0x1c20c8aeu, - 0x5bbef7ddu, 0x1b588d40u, 0xccd2017fu, 0x6bb4e3bbu, - 0xdda26a7eu, 0x3a59ff45u, 0x3e350a44u, 0xbcb4cdd5u, - 0x72eacea8u, 0xfa6484bbu, 0x8d6612aeu, 0xbf3c6f47u, - 0xd29be463u, 0x542f5d9eu, 0xaec2771bu, 0xf64e6370u, - 0x740e0d8du, 0xe75b1357u, 0xf8721671u, 0xaf537d5du, - 0x4040cb08u, 0x4eb4e2ccu, 0x34d2466au, 0x0115af84u, - 0xe1b00428u, 0x95983a1du, 0x06b89fb4u, 0xce6ea048u, - 0x6f3f3b82u, 0x3520ab82u, 0x011a1d4bu, 0x277227f8u, - 0x611560b1u, 0xe7933fdcu, 0xbb3a792bu, 0x344525bdu, - 0xa08839e1u, 0x51ce794bu, 0x2f32c9b7u, 0xa01fbac9u, - 0xe01cc87eu, 0xbcc7d1f6u, 0xcf0111c3u, 0xa1e8aac7u, - 0x1a908749u, 0xd44fbd9au, 0xd0dadecbu, 0xd50ada38u, - 0x0339c32au, 0xc6913667u, 0x8df9317cu, 0xe0b12b4fu, - 0xf79e59b7u, 0x43f5bb3au, 0xf2d519ffu, 0x27d9459cu, - 0xbf97222cu, 0x15e6fc2au, 0x0f91fc71u, 0x9b941525u, - 0xfae59361u, 0xceb69cebu, 0xc2a86459u, 0x12baa8d1u, - 0xb6c1075eu, 0xe3056a0cu, 0x10d25065u, 0xcb03a442u, - 0xe0ec6e0eu, 0x1698db3bu, 0x4c98a0beu, 0x3278e964u, - 0x9f1f9532u, 0xe0d392dfu, 0xd3a0342bu, 0x8971f21eu, - 0x1b0a7441u, 0x4ba3348cu, 0xc5be7120u, 0xc37632d8u, - 0xdf359f8du, 0x9b992f2eu, 0xe60b6f47u, 0x0fe3f11du, - 0xe54cda54u, 0x1edad891u, 0xce6279cfu, 0xcd3e7e6fu, - 0x1618b166u, 0xfd2c1d05u, 0x848fd2c5u, 0xf6fb2299u, - 0xf523f357u, 0xa6327623u, 0x93a83531u, 0x56cccd02u, - 0xacf08162u, 0x5a75ebb5u, 0x6e163697u, 0x88d273ccu, - 0xde966292u, 0x81b949d0u, 0x4c50901bu, 0x71c65614u, - 0xe6c6c7bdu, 0x327a140au, 0x45e1d006u, 0xc3f27b9au, - 0xc9aa53fdu, 0x62a80f00u, 0xbb25bfe2u, 0x35bdd2f6u, - 0x71126905u, 0xb2040222u, 0xb6cbcf7cu, 0xcd769c2bu, - 0x53113ec0u, 0x1640e3d3u, 0x38abbd60u, 0x2547adf0u, - 0xba38209cu, 0xf746ce76u, 0x77afa1c5u, 0x20756060u, - 0x85cbfe4eu, 0x8ae88dd8u, 0x7aaaf9b0u, 0x4cf9aa7eu, - 0x1948c25cu, 0x02fb8a8cu, 0x01c36ae4u, 0xd6ebe1f9u, - 0x90d4f869u, 0xa65cdea0u, 0x3f09252du, 0xc208e69fu, - 0xb74e6132u, 0xce77e25bu, 0x578fdfe3u, 0x3ac372e6u} -}; - -#define F1(i) \ - xl ^= pax[i]; \ - xr ^= ((sbx[0][xl >> 24] + \ - sbx[1][(xl & 0xFF0000) >> 16]) ^ \ - sbx[2][(xl & 0xFF00) >> 8]) + \ - sbx[3][xl & 0xFF]; - -#define F2(i) \ - xr ^= pax[i]; \ - xl ^= ((sbx[0][xr >> 24] + \ - sbx[1][(xr & 0xFF0000) >> 16]) ^ \ - sbx[2][(xr & 0xFF00) >> 8]) + \ - sbx[3][xr & 0xFF]; - - -static void bf_e_block(uint32_t *p_xl, uint32_t *p_xr) -{ - uint32_t temp; - uint32_t xl = *p_xl; - uint32_t xr = *p_xr; - - F1(0) F2(1) F1(2) F2(3) F1(4) F2(5) F1(6) F2(7) - F1(8) F2(9) F1(10) F2(11) F1(12) F2(13) F1(14) F2(15) - xl ^= pax[16]; - xr ^= pax[17]; - temp = xl; - xl = xr; - xr = temp; - *p_xl = xl; - *p_xr = xr; -} - -#ifdef WORDS_BIGENDIAN -# define htonl2(x) \ - x = ((((x) & 0xffL) << 24) | (((x) & 0xff00L) << 8) | \ - (((x) & 0xff0000L) >> 8) | (((x) & 0xff000000L) >> 24)) -#else // ifdef WORDS_BIGENDIAN -# define htonl2(x) -#endif // ifdef WORDS_BIGENDIAN - -static void bf_e_cblock(char_u *block) -{ - block8 bk; - - memcpy(bk.uc, block, 8); - htonl2(bk.ul[0]); - htonl2(bk.ul[1]); - bf_e_block(&bk.ul[0], &bk.ul[1]); - htonl2(bk.ul[0]); - htonl2(bk.ul[1]); - memcpy(block, bk.uc, 8); -} - -// Initialize the crypt method using "password" as the encryption key and -// "salt[salt_len]" as the salt. -void bf_key_init(char_u *password, char_u *salt, int salt_len) -{ - // Process the key 1000 times. - // See http://en.wikipedia.org/wiki/Key_strengthening. - char_u *key = sha256_key(password, salt, salt_len); - - int i; - for (i = 0; i < 1000; i++) { - key = sha256_key(key, salt, salt_len); - } - - // Convert the key from 64 hex chars to 32 binary chars. - int keylen = (int)STRLEN(key) / 2; - - if (keylen == 0) { - EMSG(_("E831: bf_key_init() called with empty password")); - return; - } - - unsigned u; - for (i = 0; i < keylen; i++) { - sscanf((char *)&key[i * 2], "%2x", &u); - key[i] = u; - } - - memmove(sbx, sbi, 4 * 4 * 256); - - int keypos = 0; - for (i = 0; i < 18; i++) { - uint32_t val = 0; - - int j; - for (j = 0; j < 4; j++) { - val = (val << 8) | key[keypos++ % keylen]; - } - pax[i] = ipa[i] ^ val; - } - - uint32_t data_l = 0; - uint32_t data_r = 0; - for (i = 0; i < 18; i += 2) { - bf_e_block(&data_l, &data_r); - pax[i + 0] = data_l; - pax[i + 1] = data_r; - } - - for (i = 0; i < 4; i++) { - int j; - for (j = 0; j < 256; j += 2) { - bf_e_block(&data_l, &data_r); - sbx[i][j + 0] = data_l; - sbx[i][j + 1] = data_r; - } - } -} - -/// BF Self test for corrupted tables or instructions -static int bf_check_tables(uint32_t a_ipa[18], uint32_t a_sbi[4][256], - uint32_t val) -{ - uint32_t c = 0; - int i; - for (i = 0; i < 18; i++) { - c ^= a_ipa[i]; - } - - for (i = 0; i < 4; i++) { - int j; - for (j = 0; j < 256; j++) { - c ^= a_sbi[i][j]; - } - } - return c == val; -} - -typedef struct { - char_u password[64]; - char_u salt[9]; - char_u plaintxt[9]; - char_u cryptxt[9]; - char_u badcryptxt[9]; // cryptxt when big/little endian is wrong. - uint32_t keysum; -} struct_bf_test_data; - -// Assert bf(password, plaintxt) is cryptxt. -// Assert csum(pax sbx(password)) is keysum. -static struct_bf_test_data bf_test_data[] = { - { - "password", - "salt", - "plaintxt", - "\xad\x3d\xfa\x7f\xe8\xea\x40\xf6", // cryptxt - "\x72\x50\x3b\x38\x10\x60\x22\xa7", // badcryptxt - 0x56701b5du // keysum - }, -}; - -// Return FAIL when there is something wrong with blowfish encryption. -static int bf_self_test(void) -{ - int err = 0; - if (!bf_check_tables(ipa, sbi, 0x6ffa520a)) { - err++; - } - - int bn = ARRAY_LENGTH(bf_test_data); - int i; - for (i = 0; i < bn; i++) { - bf_key_init((char_u *)(bf_test_data[i].password), bf_test_data[i].salt, - (int)STRLEN(bf_test_data[i].salt)); - - if (!bf_check_tables(pax, sbx, bf_test_data[i].keysum)) { - err++; - } - - // Don't modify bf_test_data[i].plaintxt, self test is idempotent. - block8 bk; - memcpy(bk.uc, bf_test_data[i].plaintxt, 8); - bf_e_cblock(bk.uc); - - if (memcmp(bk.uc, bf_test_data[i].cryptxt, 8) != 0) { - if ((err == 0) && (memcmp(bk.uc, bf_test_data[i].badcryptxt, 8) == 0)) { - EMSG(_("E817: Blowfish big/little endian use wrong")); - } - err++; - } - } - - return err > 0 ? FAIL : OK; -} - -// Cipher feedback mode. -static int randbyte_offset = 0; -static int update_offset = 0; -static char_u cfb_buffer[BF_CFB_LEN]; // 64 bytes - -// Initialize with seed "iv[iv_len]". -void bf_cfb_init(char_u *iv, int iv_len) -{ - randbyte_offset = update_offset = 0; - memset(cfb_buffer, 0, BF_CFB_LEN); - - if (iv_len > 0) { - int mi = iv_len > BF_CFB_LEN ? iv_len : BF_CFB_LEN; - int i; - for (i = 0; i < mi; i++) { - cfb_buffer[i % BF_CFB_LEN] ^= iv[i % iv_len]; - } - } -} - -#define BF_CFB_UPDATE(c) \ - { \ - cfb_buffer[update_offset] ^= (char_u)c; \ - if (++update_offset == BF_CFB_LEN) { \ - update_offset = 0; \ - } \ - } - -#define BF_RANBYTE(t) \ - { \ - if ((randbyte_offset & BF_BLOCK_MASK) == 0) { \ - bf_e_cblock(&cfb_buffer[randbyte_offset]); \ - } \ - t = cfb_buffer[randbyte_offset]; \ - if (++randbyte_offset == BF_CFB_LEN) { \ - randbyte_offset = 0; \ - } \ - } - -// Encrypt "from[len]" into "to[len]". -// "from" and "to" can be equal to encrypt in place. -void bf_crypt_encode(char_u *from, size_t len, char_u *to) -{ - size_t i; - for (i = 0; i < len; i++) { - int ztemp = from[i]; - int t; - BF_RANBYTE(t); - BF_CFB_UPDATE(ztemp); - to[i] = t ^ ztemp; - } -} - -/* - * Decrypt "ptr[len]" in place. - */ -void bf_crypt_decode(char_u *ptr, long len) -{ - char_u *p; - for (p = ptr; p < ptr + len; p++) { - int t; - BF_RANBYTE(t); - *p ^= t; - BF_CFB_UPDATE(*p); - } -} - -/* - * Initialize the encryption keys and the random header according to - * the given password. - * in: "passwd" password string with which to modify keys - */ -void bf_crypt_init_keys(char_u *passwd) -{ - char_u *p; - for (p = passwd; *p != NUL; p++) { - BF_CFB_UPDATE(*p); - } -} - -static int save_randbyte_offset; -static int save_update_offset; -static char_u save_cfb_buffer[BF_CFB_LEN]; -static uint32_t save_pax[18]; -static uint32_t save_sbx[4][256]; - -/* - * Save the current crypt state. Can only be used once before - * bf_crypt_restore(). - */ -void bf_crypt_save(void) -{ - save_randbyte_offset = randbyte_offset; - save_update_offset = update_offset; - memmove(save_cfb_buffer, cfb_buffer, BF_CFB_LEN); - memmove(save_pax, pax, 4 * 18); - memmove(save_sbx, sbx, 4 * 4 * 256); -} - -/* - * Restore the current crypt state. Can only be used after - * bf_crypt_save(). - */ -void bf_crypt_restore(void) -{ - randbyte_offset = save_randbyte_offset; - update_offset = save_update_offset; - memmove(cfb_buffer, save_cfb_buffer, BF_CFB_LEN); - memmove(pax, save_pax, 4 * 18); - memmove(sbx, save_sbx, 4 * 4 * 256); -} - -/* - * Run a test to check if the encryption works as expected. - * Give an error and return FAIL when not. - */ -int blowfish_self_test(void) -{ - if (sha256_self_test() == FAIL) { - EMSG(_("E818: sha256 test failed")); - return FAIL; - } - if (bf_self_test() == FAIL) { - EMSG(_("E819: Blowfish test failed")); - return FAIL; - } - return OK; -} diff --git a/src/nvim/blowfish.h b/src/nvim/blowfish.h deleted file mode 100644 index 2d1d0ba1a0..0000000000 --- a/src/nvim/blowfish.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef NVIM_BLOWFISH_H -#define NVIM_BLOWFISH_H - -void bf_key_init(char_u *password, char_u *salt, int salt_len); -void bf_cfb_init(char_u *iv, int iv_len); -void bf_crypt_encode(char_u *from, size_t len, char_u *to); -void bf_crypt_decode(char_u *ptr, long len); -void bf_crypt_init_keys(char_u *passwd); -void bf_crypt_save(void); -void bf_crypt_restore(void); -int blowfish_self_test(void); - -#endif // NVIM_BLOWFISH_H diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c index 42b7826981..03dd972df1 100644 --- a/src/nvim/buffer.c +++ b/src/nvim/buffer.c @@ -1489,9 +1489,7 @@ void free_buf_options(buf_T *buf, int free_p_ff) clear_string_option(&buf->b_p_inex); clear_string_option(&buf->b_p_inde); clear_string_option(&buf->b_p_indk); - clear_string_option(&buf->b_p_cm); clear_string_option(&buf->b_p_fex); - clear_string_option(&buf->b_p_key); clear_string_option(&buf->b_p_kp); clear_string_option(&buf->b_p_mps); clear_string_option(&buf->b_p_fo); diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h index 383cefc8d7..d658da9502 100644 --- a/src/nvim/buffer_defs.h +++ b/src/nvim/buffer_defs.h @@ -582,7 +582,6 @@ struct file_buffer { char_u *b_p_indk; /* 'indentkeys' */ char_u *b_p_fex; /* 'formatexpr' */ long_u b_p_fex_flags; /* flags for 'formatexpr' */ - char_u *b_p_key; /* 'key' */ char_u *b_p_kp; /* 'keywordprg' */ int b_p_lisp; /* 'lisp' */ char_u *b_p_mps; /* 'matchpairs' */ @@ -674,8 +673,6 @@ struct file_buffer { dictitem_T b_bufvar; /* variable for "b:" Dictionary */ dict_T *b_vars; /* internal variables, local to buffer */ - char_u *b_p_cm; /* 'cryptmethod' */ - /* When a buffer is created, it starts without a swap file. b_may_swap is * then set to indicate that a swap file may be opened later. It is reset * if a swap file could not be opened. diff --git a/src/nvim/crypt.c b/src/nvim/crypt.c deleted file mode 100644 index 2eb699d84e..0000000000 --- a/src/nvim/crypt.c +++ /dev/null @@ -1,237 +0,0 @@ -// Optional encryption support. -// Mohsin Ahmed, mosh@sasi.com, 98-09-24 -// Based on zip/crypt sources. -// -// NOTE FOR USA: Since 2000 exporting this code from the USA is allowed to -// most countries. There are a few exceptions, but that still should not be a -// problem since this code was originally created in Europe and India. -// -// Blowfish addition originally made by Mohsin Ahmed, -// http://www.cs.albany.edu/~mosh 2010-03-14 -// Based on blowfish by Bruce Schneier (http://www.schneier.com/blowfish.html) -// and sha256 by Christophe Devine. - -#include "nvim/vim.h" -#include "nvim/misc2.h" -#include "nvim/blowfish.h" -#include "nvim/ex_getln.h" -#include "nvim/message.h" -#include "nvim/option.h" -#include "nvim/strings.h" - -static void make_crc_tab(void); - -static uint32_t crc_32_tab[256]; - -// Fills the CRC table. -static void make_crc_tab(void) -{ - uint32_t s; - uint32_t t; - uint32_t v; - static bool done = false; - - if (done) { - return; - } - - for (t = 0; t < 256; t++) { - v = t; - - for (s = 0; s < 8; s++) { - v = (v >> 1) ^ ((v & 1) * (uint32_t)0xedb88320L); - } - crc_32_tab[t] = v; - } - done = true; -} - -#define CRC32(c, b) (crc_32_tab[((int)(c) ^ (b)) & 0xff] ^ ((c) >> 8)) - -static uint32_t keys[3]; // keys defining the pseudo-random sequence - -// Returns the next byte in the pseudo-random sequence. -#define DECRYPT_BYTE_ZIP(t) { \ - uint16_t temp; \ - temp = (uint16_t)keys[2] | 2; \ - t = (int)(((unsigned)(temp * (temp ^ 1U)) >> 8) & 0xff); \ -} - -// Updates the encryption keys with the next byte of plain text. -#define UPDATE_KEYS_ZIP(c) { \ - keys[0] = CRC32(keys[0], (c)); \ - keys[1] += keys[0] & 0xff; \ - keys[1] = keys[1] * 134775813L + 1; \ - keys[2] = CRC32(keys[2], (int)(keys[1] >> 24)); \ -} - -static int crypt_busy = 0; -static uint32_t saved_keys[3]; -static int saved_crypt_method; - -int crypt_method_from_string(char_u *s) -{ - return *s == 'b' ? 1 : 0; -} - -int get_crypt_method(buf_T *buf) -{ - return crypt_method_from_string(*buf->b_p_cm == NUL ? p_cm : buf->b_p_cm); -} - -void set_crypt_method(buf_T *buf, int method) -{ - free_string_option(buf->b_p_cm); - buf->b_p_cm = vim_strsave((char_u *)(method == 0 ? "zip" : "blowfish")); -} - -void crypt_push_state(void) -{ - if (crypt_busy == 1) { - // Save the state - if (use_crypt_method == 0) { - saved_keys[0] = keys[0]; - saved_keys[1] = keys[1]; - saved_keys[2] = keys[2]; - } else { - bf_crypt_save(); - } - saved_crypt_method = use_crypt_method; - } else if (crypt_busy > 1) { - EMSG2(_(e_intern2), "crypt_push_state()"); - } - crypt_busy++; -} - -void crypt_pop_state(void) -{ - crypt_busy--; - - if (crypt_busy == 1) { - use_crypt_method = saved_crypt_method; - - if (use_crypt_method == 0) { - keys[0] = saved_keys[0]; - keys[1] = saved_keys[1]; - keys[2] = saved_keys[2]; - } else { - bf_crypt_restore(); - } - } -} - -void crypt_encode(char_u *from, size_t len, char_u *to) -{ - size_t i; - int ztemp; - int t; - - if (use_crypt_method == 0) { - for (i = 0; i < len; i++) { - ztemp = from[i]; - DECRYPT_BYTE_ZIP(t); - UPDATE_KEYS_ZIP(ztemp); - to[i] = t ^ ztemp; - } - } else { - bf_crypt_encode(from, len, to); - } -} - -void crypt_decode(char_u *ptr, long len) -{ - char_u *p; - - if (use_crypt_method == 0) { - for (p = ptr; p < ptr + len; p++) { - uint16_t temp; - - temp = (uint16_t)keys[2] | 2; - temp = (int)(((unsigned)(temp * (temp ^ 1U)) >> 8) & 0xff); - UPDATE_KEYS_ZIP(*p ^= temp); - } - } else { - bf_crypt_decode(ptr, len); - } -} - -void crypt_init_keys(char_u *passwd) -{ - if ((passwd != NULL) && (*passwd != NUL)) { - if (use_crypt_method == 0) { - char_u *p; - - make_crc_tab(); - keys[0] = 305419896L; - keys[1] = 591751049L; - keys[2] = 878082192L; - - for (p = passwd; *p != NUL; p++) { - UPDATE_KEYS_ZIP((int)*p); - } - } else { - bf_crypt_init_keys(passwd); - } - } -} - -void free_crypt_key(char_u *key) -{ - char_u *p; - - if (key != NULL) { - for (p = key; *p != NUL; p++) { - *p = 0; - } - free(key); - } -} - -char_u *get_crypt_key(int store, int twice) -{ - char_u *p1; - char_u *p2 = NULL; - int round; - - for (round = 0;; round++) { - cmdline_star = TRUE; - cmdline_row = msg_row; - char_u *prompt = (round == 0) - ? (char_u *) _("Enter encryption key: ") - : (char_u *) _("Enter same key again: "); - p1 = getcmdline_prompt(NUL, prompt, 0, EXPAND_NOTHING, NULL); - cmdline_star = FALSE; - if (p1 == NULL) { - break; - } - - if (round == twice) { - if ((p2 != NULL) && (STRCMP(p1, p2) != 0)) { - MSG(_("Keys don't match!")); - free_crypt_key(p1); - free_crypt_key(p2); - p2 = NULL; - round = -1; // Do it again - continue; - } - - if (store) { - set_option_value((char_u *) "key", 0L, p1, OPT_LOCAL); - free_crypt_key(p1); - p1 = curbuf->b_p_key; - } - break; - } - p2 = p1; - } - - // Since the user typed this, no need to wait for return. - if (msg_didout) { - msg_putchar('\n'); - } - need_wait_return = FALSE; - msg_didout = FALSE; - - free_crypt_key(p2); - return p1; -} diff --git a/src/nvim/crypt.h b/src/nvim/crypt.h deleted file mode 100644 index 388443787d..0000000000 --- a/src/nvim/crypt.h +++ /dev/null @@ -1,82 +0,0 @@ -#ifndef NVIM_CRYPT_H -#define NVIM_CRYPT_H - -/// Returns the crypt method string as a number. -/// -/// @param s Pointer to the crypt method string. -/// -/// @return An integer value of the crypt method: -/// 0 for "zip", the old method. Also for any non-valid value. -/// 1 for "blowfish". -int crypt_method_from_string(char_u *s); - -/// Returns the crypt method of the buffer "buf" as a number. -/// -/// @param buf Pointer to the buffer. -/// -/// @return An integer value of the crypt method: -/// 0 for "zip", the old method. Also for any non-valid value. -/// 1 for "blowfish". -int get_crypt_method(buf_T *buf); - -/// Sets the crypt method for buffer "buf" to "method" using the -/// int value as returned by crypt_method_from_string(). -/// -/// @param buf Pointer to the buffer. -/// @param method Crypt method. -void set_crypt_method(buf_T *buf, int method); - -/// Prepares for initializing the encryption. If already doing encryption, -/// then save the state. -/// -/// This function must always be called symmetrically with crypt_pop_state(). -void crypt_push_state(void); - -/// Ends encryption. If already doing encryption before crypt_push_state(), -/// then restore the saved state. -/// -/// This function must always be called symmetrically with crypt_push_state(). -void crypt_pop_state(void); - -/// Encrypts "from[len]" into "to[len]". -/// For in-place encryption, "from" and "len" must be the same. -/// -/// @param from Pointer to the source string. -/// @param len Length of the strings. -/// @param to Pointer to the destination string. -void crypt_encode(char_u *from, size_t len, char_u *to); - -/// Decrypts "ptr[len]" in-place. -/// -/// @param ptr Pointer to the string. -/// @param len Length of the string. -void crypt_decode(char_u *ptr, long len); - -/// Initializes the encryption keys and the random header according to -/// the given password. -/// -/// If "password" is NULL or empty, the function doesn't do anything. -/// -/// @param passwd The password string with which to modify keys. -void crypt_init_keys(char_u *passwd); - -/// Frees an allocated crypt key and clears the text to make sure -/// nothing stays in memory. -/// -/// @param key The crypt key to be freed. -void free_crypt_key(char_u *key); - -/// Asks the user for the crypt key. -/// -/// When "store" is TRUE, the new key is stored in the 'key' option -/// and the 'key' option value is returned, which MUST NOT be freed -/// manually, but using free_crypt_key(). -/// When "store" is FALSE, the typed key is returned in allocated memory. -/// -/// @param store Determines, whether the new crypt key is stored. -/// @param twice Ask for the key twice. -/// -/// @return The crypt key. On failure, NULL is returned. -char_u *get_crypt_key(int store, int twice); - -#endif // NVIM_CRYPT_H diff --git a/src/nvim/eval.c b/src/nvim/eval.c index 86b8aaecba..6e0681420b 100644 --- a/src/nvim/eval.c +++ b/src/nvim/eval.c @@ -713,7 +713,6 @@ static void f_setreg(typval_T *argvars, typval_T *rettv); static void f_settabvar(typval_T *argvars, typval_T *rettv); static void f_settabwinvar(typval_T *argvars, typval_T *rettv); static void f_setwinvar(typval_T *argvars, typval_T *rettv); -static void f_sha256(typval_T *argvars, typval_T *rettv); static void f_shellescape(typval_T *argvars, typval_T *rettv); static void f_shiftwidth(typval_T *argvars, typval_T *rettv); static void f_simplify(typval_T *argvars, typval_T *rettv); @@ -6994,7 +6993,6 @@ static struct fst { {"settabvar", 3, 3, f_settabvar}, {"settabwinvar", 4, 4, f_settabwinvar}, {"setwinvar", 3, 3, f_setwinvar}, - {"sha256", 1, 1, f_sha256}, {"shellescape", 1, 2, f_shellescape}, {"shiftwidth", 0, 0, f_shiftwidth}, {"simplify", 1, 1, f_simplify}, @@ -10204,7 +10202,6 @@ static void f_has(typval_T *argvars, typval_T *rettv) "cmdline_hist", "comments", "conceal", - "cryptv", "cscope", "cursorbind", "cursorshape", @@ -13660,19 +13657,6 @@ static void setwinvar(typval_T *argvars, typval_T *rettv, int off) } /* - * "sha256({string})" function - */ -static void f_sha256(typval_T *argvars, typval_T *rettv) -{ - char_u *p; - - p = get_tv_string(&argvars[0]); - rettv->vval.v_string = vim_strsave( - sha256_bytes(p, (int)STRLEN(p), NULL, 0)); - rettv->v_type = VAR_STRING; -} - -/* * "shellescape({string})" function */ static void f_shellescape(typval_T *argvars, typval_T *rettv) diff --git a/src/nvim/ex_cmds_defs.h b/src/nvim/ex_cmds_defs.h index b6285db274..85cd4cd2fe 100644 --- a/src/nvim/ex_cmds_defs.h +++ b/src/nvim/ex_cmds_defs.h @@ -1084,8 +1084,6 @@ enum CMD_index EXTRA|RANGE|NOTADR|COUNT|BANG|EDITCMD|ARGOPT|TRLBAR), EX(CMD_Print, "Print", ex_print, RANGE|WHOLEFOLD|COUNT|EXFLAGS|TRLBAR|CMDWIN), - EX(CMD_X, "X", ex_X, - TRLBAR), EX(CMD_tilde, "~", do_sub, RANGE|WHOLEFOLD|EXTRA|CMDWIN|MODIFY), diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c index 368d5c9b0c..7007cd3e22 100644 --- a/src/nvim/ex_docmd.c +++ b/src/nvim/ex_docmd.c @@ -14,7 +14,6 @@ #include "nvim/vim.h" #include "nvim/ex_docmd.h" -#include "nvim/blowfish.h" #include "nvim/buffer.h" #include "nvim/charset.h" #include "nvim/diff.h" @@ -40,7 +39,6 @@ #include "nvim/misc1.h" #include "nvim/misc2.h" #include "nvim/keymap.h" -#include "nvim/crypt.h" #include "nvim/file_search.h" #include "nvim/garray.h" #include "nvim/move.h" @@ -224,7 +222,6 @@ static void ex_digraphs(exarg_T *eap); static void ex_set(exarg_T *eap); static void ex_nohlsearch(exarg_T *eap); static void ex_match(exarg_T *eap); -static void ex_X(exarg_T *eap); static void ex_fold(exarg_T *eap); static void ex_foldopen(exarg_T *eap); static void ex_folddo(exarg_T *eap); @@ -9074,15 +9071,6 @@ static void ex_match(exarg_T *eap) eap->nextcmd = find_nextcmd(end); } -/* - * ":X": Get crypt key - */ -static void ex_X(exarg_T *eap) -{ - if (get_crypt_method(curbuf) == 0 || blowfish_self_test() == OK) - (void)get_crypt_key(TRUE, TRUE); -} - static void ex_fold(exarg_T *eap) { if (foldManualAllowed(TRUE)) diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c index 4112c5288d..214b38dea7 100644 --- a/src/nvim/fileio.c +++ b/src/nvim/fileio.c @@ -14,7 +14,6 @@ #include "nvim/vim.h" #include "nvim/fileio.h" -#include "nvim/blowfish.h" #include "nvim/buffer.h" #include "nvim/charset.h" #include "nvim/diff.h" @@ -33,7 +32,6 @@ #include "nvim/message.h" #include "nvim/misc1.h" #include "nvim/misc2.h" -#include "nvim/crypt.h" #include "nvim/garray.h" #include "nvim/move.h" #include "nvim/normal.h" @@ -52,7 +50,6 @@ #include "nvim/window.h" #include "nvim/os/os.h" - #if defined(HAVE_UTIME) && defined(HAVE_UTIME_H) # include <utime.h> /* for struct utimbuf */ #endif @@ -60,27 +57,10 @@ #define BUFSIZE 8192 /* size of normal write buffer */ #define SMBUFSIZE 256 /* size of emergency write buffer */ -/* crypt_magic[0] is pkzip crypt, crypt_magic[1] is sha2+blowfish */ -static char *crypt_magic[] = {"VimCrypt~01!", "VimCrypt~02!"}; -static char crypt_magic_head[] = "VimCrypt~"; -# define CRYPT_MAGIC_LEN 12 /* must be multiple of 4! */ - -/* For blowfish, after the magic header, we store 8 bytes of salt and then 8 - * bytes of seed (initialisation vector). */ -static int crypt_salt_len[] = {0, 8}; -static int crypt_seed_len[] = {0, 8}; -#define CRYPT_SALT_LEN_MAX 8 -#define CRYPT_SEED_LEN_MAX 8 - static char_u *next_fenc(char_u **pp); static char_u *readfile_charconvert(char_u *fname, char_u *fenc, int *fdp); static void check_marks_read(void); -static int crypt_method_from_magic(char *ptr, int len); -static char_u *check_for_cryptkey(char_u *cryptkey, char_u *ptr, - long *sizep, off_t *filesizep, - int newfile, char_u *fname, - int *did_ask); #ifdef UNIX static void set_file_time(char_u *fname, time_t atime, time_t mtime); #endif @@ -105,7 +85,6 @@ static int au_find_group(char_u *name); # define FIO_UCS4 0x08 /* convert UCS-4 */ # define FIO_UTF16 0x10 /* convert UTF-16 */ # define FIO_ENDIAN_L 0x80 /* little endian */ -# define FIO_ENCRYPTED 0x1000 /* encrypt written bytes */ # define FIO_NOCONVERT 0x2000 /* skip encoding conversion */ # define FIO_UCSBOM 0x4000 /* check for BOM at start of file */ # define FIO_ALL -1 /* allow all formats */ @@ -245,9 +224,6 @@ readfile ( char_u *p; off_t filesize = 0; int skip_read = FALSE; - char_u *cryptkey = NULL; - int did_ask_for_key = FALSE; - int crypt_method_used; context_sha256_T sha_ctx; int read_undo_file = FALSE; int split = 0; /* number of split lines */ @@ -812,11 +788,6 @@ retry: conv_error = 0; } - if (cryptkey != NULL) - /* Need to reset the state, but keep the key, don't want to ask for it - * again. */ - crypt_pop_state(); - /* * When retrying with another "fenc" and the first time "fileformat" * will be reset. @@ -1147,34 +1118,17 @@ retry: } } } - - /* - * At start of file: Check for magic number of encryption. - */ - if (filesize == 0) - cryptkey = check_for_cryptkey(cryptkey, ptr, &size, - &filesize, newfile, sfname, - &did_ask_for_key); - /* - * Decrypt the read bytes. - */ - if (cryptkey != NULL && size > 0) - crypt_decode(ptr, size); } + skip_read = FALSE; /* - * At start of file (or after crypt magic number): Check for BOM. + * At start of file: Check for BOM. * Also check for a BOM for other Unicode encodings, but not after * converting with 'charconvert' or when a BOM has already been * found. */ - if ((filesize == 0 - || (filesize == (CRYPT_MAGIC_LEN - + crypt_salt_len[use_crypt_method] - + crypt_seed_len[use_crypt_method]) - && cryptkey != NULL) - ) + if ((filesize == 0) && (fio_flags == FIO_UCSBOM || (!curbuf->b_p_bomb && tmpname == NULL @@ -1734,15 +1688,6 @@ failed: if (set_options) save_file_ff(curbuf); /* remember the current file format */ - crypt_method_used = use_crypt_method; - if (cryptkey != NULL) { - crypt_pop_state(); - if (cryptkey != curbuf->b_p_key) - free_crypt_key(cryptkey); - /* don't set cryptkey to NULL, it's used below as a flag that - * encryption was used */ - } - /* If editing a new file: set 'fenc' for the current buffer. * Also for ":read ++edit file". */ if (set_options) @@ -1881,13 +1826,6 @@ failed: STRCAT(IObuff, _("[converted]")); c = TRUE; } - if (cryptkey != NULL) { - if (crypt_method_used == 1) - STRCAT(IObuff, _("[blowfish]")); - else - STRCAT(IObuff, _("[crypted]")); - c = TRUE; - } if (conv_error != 0) { sprintf((char *)IObuff + STRLEN(IObuff), _("[CONVERSION ERROR in line %" PRId64 "]"), (int64_t)conv_error); @@ -1902,12 +1840,6 @@ failed: } if (msg_add_fileformat(fileformat)) c = TRUE; - if (cryptkey != NULL) - msg_add_lines(c, (long)linecnt, filesize - - CRYPT_MAGIC_LEN - - crypt_salt_len[use_crypt_method] - - crypt_seed_len[use_crypt_method]); - else msg_add_lines(c, (long)linecnt, filesize); free(keep_msg); @@ -2217,178 +2149,6 @@ static void check_marks_read(void) curbuf->b_marks_read = TRUE; } -/* - * Get the crypt method used for a file from "ptr[len]", the magic text at the - * start of the file. - * Returns -1 when no encryption used. - */ -static int crypt_method_from_magic(char *ptr, int len) -{ - int i; - - for (i = 0; i < (int)(sizeof(crypt_magic) / sizeof(crypt_magic[0])); i++) { - if (len < (CRYPT_MAGIC_LEN + crypt_salt_len[i] + crypt_seed_len[i])) - continue; - if (memcmp(ptr, crypt_magic[i], CRYPT_MAGIC_LEN) == 0) - return i; - } - - i = (int)STRLEN(crypt_magic_head); - if (len >= i && memcmp(ptr, crypt_magic_head, i) == 0) - EMSG(_("E821: File is encrypted with unknown method")); - - return -1; -} - -/* - * Check for magic number used for encryption. Applies to the current buffer. - * If found, the magic number is removed from ptr[*sizep] and *sizep and - * *filesizep are updated. - * Return the (new) encryption key, NULL for no encryption. - */ -static char_u * -check_for_cryptkey ( - char_u *cryptkey, /* previous encryption key or NULL */ - char_u *ptr, /* pointer to read bytes */ - long *sizep, /* length of read bytes */ - off_t *filesizep, /* nr of bytes used from file */ - int newfile, /* editing a new buffer */ - char_u *fname, /* file name to display */ - int *did_ask /* flag: whether already asked for key */ -) -{ - int method = crypt_method_from_magic((char *)ptr, *sizep); - int b_p_ro = curbuf->b_p_ro; - - if (method >= 0) { - /* Mark the buffer as read-only until the decryption has taken place. - * Avoids accidentally overwriting the file with garbage. */ - curbuf->b_p_ro = TRUE; - - set_crypt_method(curbuf, method); - if (method > 0) - (void)blowfish_self_test(); - if (cryptkey == NULL && !*did_ask) { - if (*curbuf->b_p_key) - cryptkey = curbuf->b_p_key; - else { - /* When newfile is TRUE, store the typed key in the 'key' - * option and don't free it. bf needs hash of the key saved. - * Don't ask for the key again when first time Enter was hit. - * Happens when retrying to detect encoding. */ - smsg((char_u *)_(need_key_msg), fname); - msg_scroll = TRUE; - cryptkey = get_crypt_key(newfile, FALSE); - *did_ask = TRUE; - - /* check if empty key entered */ - if (cryptkey != NULL && *cryptkey == NUL) { - if (cryptkey != curbuf->b_p_key) - free(cryptkey); - cryptkey = NULL; - } - } - } - - if (cryptkey != NULL) { - int seed_len = crypt_seed_len[method]; - int salt_len = crypt_salt_len[method]; - - crypt_push_state(); - use_crypt_method = method; - if (method == 0) - crypt_init_keys(cryptkey); - else { - bf_key_init(cryptkey, ptr + CRYPT_MAGIC_LEN, salt_len); - bf_cfb_init(ptr + CRYPT_MAGIC_LEN + salt_len, seed_len); - } - - /* Remove magic number from the text */ - *filesizep += CRYPT_MAGIC_LEN + salt_len + seed_len; - *sizep -= CRYPT_MAGIC_LEN + salt_len + seed_len; - memmove(ptr, ptr + CRYPT_MAGIC_LEN + salt_len + seed_len, - (size_t)*sizep); - /* Restore the read-only flag. */ - curbuf->b_p_ro = b_p_ro; - } - } - /* When starting to edit a new file which does not have encryption, clear - * the 'key' option, except when starting up (called with -x argument) */ - else if (newfile && *curbuf->b_p_key != NUL && !starting) - set_option_value((char_u *)"key", 0L, (char_u *)"", OPT_LOCAL); - - return cryptkey; -} - -/* - * Check for magic number used for encryption. Applies to the current buffer. - * If found and decryption is possible returns OK; - */ -int prepare_crypt_read(FILE *fp) -{ - int method; - char_u buffer[CRYPT_MAGIC_LEN + CRYPT_SALT_LEN_MAX - + CRYPT_SEED_LEN_MAX + 2]; - - if (fread(buffer, CRYPT_MAGIC_LEN, 1, fp) != 1) - return FAIL; - method = crypt_method_from_magic((char *)buffer, - CRYPT_MAGIC_LEN + - CRYPT_SEED_LEN_MAX + - CRYPT_SALT_LEN_MAX); - if (method < 0 || method != get_crypt_method(curbuf)) - return FAIL; - - crypt_push_state(); - if (method == 0) - crypt_init_keys(curbuf->b_p_key); - else { - int salt_len = crypt_salt_len[method]; - int seed_len = crypt_seed_len[method]; - - if (fread(buffer, salt_len + seed_len, 1, fp) != 1) - return FAIL; - bf_key_init(curbuf->b_p_key, buffer, salt_len); - bf_cfb_init(buffer + salt_len, seed_len); - } - return OK; -} - -/* - * Prepare for writing encrypted bytes for buffer "buf". - * Returns a pointer to an allocated header of length "*lenp". - * When out of memory returns NULL. - * Otherwise calls crypt_push_state(), call crypt_pop_state() later. - */ -char_u *prepare_crypt_write(buf_T *buf, int *lenp) -{ - char_u *header = xcalloc(1, CRYPT_MAGIC_LEN + CRYPT_SALT_LEN_MAX - + CRYPT_SEED_LEN_MAX + 2); - int seed_len = crypt_seed_len[get_crypt_method(buf)]; - int salt_len = crypt_salt_len[get_crypt_method(buf)]; - char_u *salt; - char_u *seed; - - crypt_push_state(); - use_crypt_method = get_crypt_method(buf); /* select zip or blowfish */ - vim_strncpy(header, (char_u *)crypt_magic[use_crypt_method], - CRYPT_MAGIC_LEN); - if (use_crypt_method == 0) - crypt_init_keys(buf->b_p_key); - else { - /* Using blowfish, add salt and seed. */ - salt = header + CRYPT_MAGIC_LEN; - seed = salt + salt_len; - sha2_seed(salt, salt_len, seed, seed_len); - bf_key_init(buf->b_p_key, salt, salt_len); - bf_cfb_init(seed, seed_len); - } - - *lenp = CRYPT_MAGIC_LEN + salt_len + seed_len; - return header; -} - - #ifdef UNIX static void set_file_time ( @@ -2501,7 +2261,6 @@ buf_write ( #endif int write_undo_file = FALSE; context_sha256_T sha_ctx; - int crypt_method_used; if (fname == NULL || *fname == NUL) /* safety check */ return FAIL; @@ -3477,28 +3236,6 @@ restore_backup: write_info.bw_fd = fd; - - if (*buf->b_p_key != NUL && !filtering) { - char_u *header; - int header_len; - - header = prepare_crypt_write(buf, &header_len); - if (header == NULL) - end = 0; - else { - /* Write magic number, so that Vim knows that this file is - * encrypted when reading it again. This also undergoes utf-8 to - * ucs-2/4 conversion when needed. */ - write_info.bw_buf = header; - write_info.bw_len = header_len; - write_info.bw_flags = FIO_NOCONVERT; - if (buf_write_bytes(&write_info) == FAIL) - end = 0; - wb_flags |= FIO_ENCRYPTED; - free(header); - } - } - write_info.bw_buf = buffer; nchars = 0; @@ -3509,14 +3246,13 @@ restore_backup: write_bin = buf->b_p_bin; /* - * The BOM is written just after the encryption magic number. - * Skip it when appending and the file already existed, the BOM only makes - * sense at the start of the file. + * Skip the BOM when appending and the file already existed, the BOM + * only makes sense at the start of the file. */ if (buf->b_p_bomb && !write_bin && (!append || perm < 0)) { write_info.bw_len = make_bom(buffer, fenc); if (write_info.bw_len > 0) { - /* don't convert, do encryption */ + /* don't convert */ write_info.bw_flags = FIO_NOCONVERT | wb_flags; if (buf_write_bytes(&write_info) == FAIL) end = 0; @@ -3677,10 +3413,6 @@ restore_backup: if (!backup_copy) mch_set_acl(wfname, acl); #endif - crypt_method_used = use_crypt_method; - if (wb_flags & FIO_ENCRYPTED) - crypt_pop_state(); - if (wfname != fname) { /* @@ -3799,13 +3531,6 @@ restore_backup: /* may add [unix/dos/mac] */ if (msg_add_fileformat(fileformat)) c = TRUE; - if (wb_flags & FIO_ENCRYPTED) { - if (crypt_method_used == 1) - STRCAT(IObuff, _("[blowfish]")); - else - STRCAT(IObuff, _("[crypted]")); - c = TRUE; - } msg_add_lines(c, (long)lnum, nchars); /* add line/char count */ if (!shortmess(SHM_WRITE)) { if (append) @@ -4163,7 +3888,7 @@ static int time_differs(long t1, long t2) /* * Call write() to write a number of bytes to the file. - * Handles encryption and 'encoding' conversion. + * Handles 'encoding' conversion. * * Return FAIL for failure, OK otherwise. */ @@ -4177,7 +3902,7 @@ static int buf_write_bytes(struct bw_info *ip) #endif /* - * Skip conversion when writing the crypt magic number or the BOM. + * Skip conversion when writing the BOM. */ if (!(flags & FIO_NOCONVERT)) { char_u *p; @@ -4366,9 +4091,6 @@ static int buf_write_bytes(struct bw_info *ip) # endif } - if (flags & FIO_ENCRYPTED) /* encrypt the data */ - crypt_encode(buf, len, buf); - wlen = write_eintr(ip->bw_fd, buf, len); return (wlen < len) ? FAIL : OK; } diff --git a/src/nvim/fileio.h b/src/nvim/fileio.h index a69f3a287e..2d61c21fb5 100644 --- a/src/nvim/fileio.h +++ b/src/nvim/fileio.h @@ -25,8 +25,6 @@ int readfile(char_u *fname, char_u *sfname, linenr_T from, void prep_exarg(exarg_T *eap, buf_T *buf); void set_file_options(int set_options, exarg_T *eap); void set_forced_fenc(exarg_T *eap); -int prepare_crypt_read(FILE *fp); -char_u *prepare_crypt_write(buf_T *buf, int *lenp); int buf_write(buf_T *buf, char_u *fname, char_u *sfname, linenr_T start, linenr_T end, exarg_T *eap, int append, int forceit, int reset_changed, diff --git a/src/nvim/globals.h b/src/nvim/globals.h index a2efb961cd..869972e3b4 100644 --- a/src/nvim/globals.h +++ b/src/nvim/globals.h @@ -103,8 +103,6 @@ EXTERN int exec_from_reg INIT(= FALSE); /* executing register */ EXTERN int screen_cleared INIT(= FALSE); /* screen has been cleared */ -EXTERN int use_crypt_method INIT(= 0); - /* * When '$' is included in 'cpoptions' option set: * When a change command is given that deletes only part of a line, a dollar @@ -1116,8 +1114,6 @@ EXTERN char_u e_invalidreg[] INIT(= N_("E850: Invalid register name")); EXTERN char top_bot_msg[] INIT(= N_("search hit TOP, continuing at BOTTOM")); EXTERN char bot_top_msg[] INIT(= N_("search hit BOTTOM, continuing at TOP")); -EXTERN char need_key_msg[] INIT(= N_("Need encryption key for \"%s\"")); - /* For undo we need to know the lowest time possible. */ EXTERN time_t starttime; diff --git a/src/nvim/main.c b/src/nvim/main.c index 16a155fa20..8d7fbe0a02 100644 --- a/src/nvim/main.c +++ b/src/nvim/main.c @@ -12,7 +12,6 @@ #include "nvim/vim.h" #include "nvim/main.h" -#include "nvim/blowfish.h" #include "nvim/buffer.h" #include "nvim/charset.h" #include "nvim/diff.h" @@ -31,7 +30,6 @@ #include "nvim/message.h" #include "nvim/misc1.h" #include "nvim/misc2.h" -#include "nvim/crypt.h" #include "nvim/garray.h" #include "nvim/log.h" #include "nvim/memory.h" @@ -82,7 +80,6 @@ typedef struct { int want_full_screen; bool stdout_isatty; /* is stdout a terminal? */ char_u *term; /* specified terminal name */ - int ask_for_key; /* -x argument */ int no_swap_file; /* "-n" argument used */ int use_debug_break_level; int window_count; /* number of windows to use */ @@ -454,12 +451,6 @@ static char *(main_errors[]) = TIME_MSG("clearing screen"); } - if (params.ask_for_key) { - (void)blowfish_self_test(); - (void)get_crypt_key(TRUE, TRUE); - TIME_MSG("getting crypt key"); - } - no_wait_return = TRUE; /* @@ -1250,10 +1241,6 @@ static void command_line_scan(mparm_T *parmp) want_argument = TRUE; break; - case 'x': /* "-x" encrypted reading/writing of files */ - parmp->ask_for_key = TRUE; - break; - case 'X': /* "-X" don't connect to X server */ break; @@ -2250,7 +2237,6 @@ static void usage(void) main_msg(_("-s <scriptin>\tRead Normal mode commands from file <scriptin>")); main_msg(_("-w <scriptout>\tAppend all typed commands to file <scriptout>")); main_msg(_("-W <scriptout>\tWrite all typed commands to file <scriptout>")); - main_msg(_("-x\t\t\tEdit encrypted files")); #ifdef STARTUPTIME main_msg(_("--startuptime <file>\tWrite startup timing messages to <file>")); #endif diff --git a/src/nvim/memfile.c b/src/nvim/memfile.c index 77468bb855..bf40d27502 100644 --- a/src/nvim/memfile.c +++ b/src/nvim/memfile.c @@ -132,7 +132,6 @@ memfile_T *mf_open(char_u *fname, int flags) mf_hash_init(&mfp->mf_hash); mf_hash_init(&mfp->mf_trans); mfp->mf_page_size = MEMFILE_PAGE_SIZE; - mfp->mf_old_key = NULL; /* * Try to set the page size equal to the block size of the device. @@ -814,10 +813,6 @@ static int mf_read(memfile_T *mfp, bhdr_T *hp) return FAIL; } - /* Decrypt if 'key' is set and this is a data block. */ - if (*mfp->mf_buffer->b_p_key != NUL) - ml_decrypt_data(mfp, hp->bh_data, offset, size); - return OK; } @@ -894,7 +889,6 @@ static int mf_write(memfile_T *mfp, bhdr_T *hp) /* * Write block "hp" with data size "size" to file "mfp->mf_fd". - * Takes care of encryption. * Return FAIL or OK. */ static int mf_write_block(memfile_T *mfp, bhdr_T *hp, off_t offset, unsigned size) @@ -902,17 +896,9 @@ static int mf_write_block(memfile_T *mfp, bhdr_T *hp, off_t offset, unsigned siz char_u *data = hp->bh_data; int result = OK; - /* Encrypt if 'key' is set and this is a data block. */ - if (*mfp->mf_buffer->b_p_key != NUL) { - data = ml_encrypt_data(mfp, data, offset, size); - } - if ((unsigned)write_eintr(mfp->mf_fd, data, size) != size) result = FAIL; - if (data != hp->bh_data) - free(data); - return result; } diff --git a/src/nvim/memfile_defs.h b/src/nvim/memfile_defs.h index 5a37103f62..818246d6db 100644 --- a/src/nvim/memfile_defs.h +++ b/src/nvim/memfile_defs.h @@ -75,8 +75,6 @@ struct nr_trans { blocknr_T nt_new_bnum; /* new, positive, number */ }; -#define MF_SEED_LEN 8 - struct memfile { char_u *mf_fname; /* name of the file */ char_u *mf_ffname; /* idem, full path */ @@ -94,14 +92,6 @@ struct memfile { blocknr_T mf_infile_count; /* number of pages in the file */ unsigned mf_page_size; /* number of bytes in a page */ int mf_dirty; /* TRUE if there are dirty blocks */ - buf_T *mf_buffer; /* bufer this memfile is for */ - char_u mf_seed[MF_SEED_LEN]; /* seed for encryption */ - - /* Values for key, method and seed used for reading data blocks when - * updating for a newly set key or method. Only when mf_old_key != NULL. */ - char_u *mf_old_key; - int mf_old_cm; - char_u mf_old_seed[MF_SEED_LEN]; }; #endif // NVIM_MEMFILE_DEFS_H diff --git a/src/nvim/memline.c b/src/nvim/memline.c index 28f3f2a9cc..8d0bd9a6d0 100644 --- a/src/nvim/memline.c +++ b/src/nvim/memline.c @@ -45,7 +45,6 @@ #include "nvim/vim.h" #include "nvim/memline.h" -#include "nvim/blowfish.h" #include "nvim/buffer.h" #include "nvim/eval.h" #include "nvim/fileio.h" @@ -57,7 +56,6 @@ #include "nvim/message.h" #include "nvim/misc1.h" #include "nvim/misc2.h" -#include "nvim/crypt.h" #include "nvim/option.h" #include "nvim/os_unix.h" #include "nvim/path.h" @@ -199,12 +197,6 @@ struct block0 { */ #define b0_flags b0_fname[B0_FNAME_SIZE_ORG - 2] -/* - * Crypt seed goes here, 8 bytes. New in Vim 7.3. - * Without encryption these bytes may be used for 'fenc'. - */ -#define b0_seed b0_fname[B0_FNAME_SIZE_ORG - 2 - MF_SEED_LEN] - /* The lowest two bits contain the fileformat. Zero means it's not set * (compatible with Vim 6.x), otherwise it's EOL_UNIX + 1, EOL_DOS + 1 or * EOL_MAC + 1. */ @@ -241,10 +233,8 @@ static linenr_T lowest_marked = 0; typedef enum { UB_FNAME = 0 /* update timestamp and filename */ , UB_SAME_DIR /* update the B0_SAME_DIR flag */ - , UB_CRYPT /* update crypt key */ } upd_block0_T; -static void ml_set_b0_crypt(buf_T *buf, ZERO_BL *b0p); static int ml_check_b0_id(ZERO_BL *b0p); static void ml_upd_block0(buf_T *buf, upd_block0_T what); static void set_b0_fname(ZERO_BL *, buf_T *buf); @@ -270,7 +260,6 @@ static long char_to_long(char_u *); #if defined(UNIX) || defined(WIN3264) static char_u *make_percent_swname(char_u *dir, char_u *name); #endif -static void ml_crypt_prepare(memfile_T *mfp, off_t offset, int reading); static void ml_updatechunk(buf_T *buf, long line, long len, int updtype); /* @@ -316,7 +305,6 @@ int ml_open(buf_T *buf) goto error; buf->b_ml.ml_mfp = mfp; - mfp->mf_buffer = buf; buf->b_ml.ml_flags = ML_EMPTY; buf->b_ml.ml_line_count = 1; curwin->w_nrwidth_line_count = 0; @@ -352,8 +340,6 @@ int ml_open(buf_T *buf) os_get_hostname((char *)b0p->b0_hname, B0_HNAME_SIZE); b0p->b0_hname[B0_HNAME_SIZE - 1] = NUL; long_to_char(os_get_pid(), b0p->b0_pid); - if (*buf->b_p_key != NUL) - ml_set_b0_crypt(buf, b0p); } /* @@ -413,141 +399,6 @@ error: } /* - * Prepare encryption for "buf" with block 0 "b0p". - */ -static void ml_set_b0_crypt(buf_T *buf, ZERO_BL *b0p) -{ - if (*buf->b_p_key == NUL) - b0p->b0_id[1] = BLOCK0_ID1; - else { - if (get_crypt_method(buf) == 0) - b0p->b0_id[1] = BLOCK0_ID1_C0; - else { - b0p->b0_id[1] = BLOCK0_ID1_C1; - /* Generate a seed and store it in block 0 and in the memfile. */ - sha2_seed(&b0p->b0_seed, MF_SEED_LEN, NULL, 0); - memmove(buf->b_ml.ml_mfp->mf_seed, &b0p->b0_seed, MF_SEED_LEN); - } - } -} - -/* - * Called after the crypt key or 'cryptmethod' was changed for "buf". - * Will apply this to the swapfile. - * "old_key" is the previous key. It is equal to buf->b_p_key when - * 'cryptmethod' is changed. - * "old_cm" is the previous 'cryptmethod'. It is equal to the current - * 'cryptmethod' when 'key' is changed. - */ -void ml_set_crypt_key(buf_T *buf, char_u *old_key, int old_cm) -{ - memfile_T *mfp = buf->b_ml.ml_mfp; - bhdr_T *hp; - int page_count; - int idx; - long error; - infoptr_T *ip; - PTR_BL *pp; - DATA_BL *dp; - blocknr_T bnum; - int top; - - if (mfp == NULL) - return; /* no memfile yet, nothing to do */ - - /* Set the key, method and seed to be used for reading, these must be the - * old values. */ - mfp->mf_old_key = old_key; - mfp->mf_old_cm = old_cm; - if (old_cm > 0) - memmove(mfp->mf_old_seed, mfp->mf_seed, MF_SEED_LEN); - - /* Update block 0 with the crypt flag and may set a new seed. */ - ml_upd_block0(buf, UB_CRYPT); - - if (mfp->mf_infile_count > 2) { - /* - * Need to read back all data blocks from disk, decrypt them with the - * old key/method and mark them to be written. The algorithm is - * similar to what happens in ml_recover(), but we skip negative block - * numbers. - */ - ml_flush_line(buf); /* flush buffered line */ - (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush locked block */ - - hp = NULL; - bnum = 1; /* start with block 1 */ - page_count = 1; /* which is 1 page */ - idx = 0; /* start with first index in block 1 */ - error = 0; - buf->b_ml.ml_stack_top = 0; - free(buf->b_ml.ml_stack); - buf->b_ml.ml_stack = NULL; - buf->b_ml.ml_stack_size = 0; /* no stack yet */ - - for (; !got_int; line_breakcheck()) { - if (hp != NULL) - mf_put(mfp, hp, FALSE, FALSE); /* release previous block */ - - /* get the block (pointer or data) */ - if ((hp = mf_get(mfp, (blocknr_T)bnum, page_count)) == NULL) { - if (bnum == 1) - break; - ++error; - } else { - pp = (PTR_BL *)(hp->bh_data); - if (pp->pb_id == PTR_ID) { /* it is a pointer block */ - if (pp->pb_count == 0) { - /* empty block? */ - ++error; - } else if (idx < (int)pp->pb_count) { /* go a block deeper */ - if (pp->pb_pointer[idx].pe_bnum < 0) { - /* Skip data block with negative block number. */ - ++idx; /* get same block again for next index */ - continue; - } - - /* going one block deeper in the tree, new entry in - * stack */ - top = ml_add_stack(buf); - ip = &(buf->b_ml.ml_stack[top]); - ip->ip_bnum = bnum; - ip->ip_index = idx; - - bnum = pp->pb_pointer[idx].pe_bnum; - page_count = pp->pb_pointer[idx].pe_page_count; - continue; - } - } else { /* not a pointer block */ - dp = (DATA_BL *)(hp->bh_data); - if (dp->db_id != DATA_ID) /* block id wrong */ - ++error; - else { - /* It is a data block, need to write it back to disk. */ - mf_put(mfp, hp, TRUE, FALSE); - hp = NULL; - } - } - } - - if (buf->b_ml.ml_stack_top == 0) /* finished */ - break; - - /* go one block up in the tree */ - ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]); - bnum = ip->ip_bnum; - idx = ip->ip_index + 1; /* go to next index */ - page_count = 1; - } - - if (error > 0) - EMSG(_("E843: Error while updating swap file crypt")); - } - - mfp->mf_old_key = NULL; -} - -/* * ml_setname() is called when the file name of "buf" has been changed. * It may rename the swap file. */ @@ -818,8 +669,6 @@ static void ml_upd_block0(buf_T *buf, upd_block0_T what) else { if (what == UB_FNAME) set_b0_fname(b0p, buf); - else if (what == UB_CRYPT) - ml_set_b0_crypt(buf, b0p); else /* what == UB_SAME_DIR */ set_b0_dir_flag(b0p, buf); } @@ -906,12 +755,6 @@ static void add_b0_fenc(ZERO_BL *b0p, buf_T *buf) int n; int size = B0_FNAME_SIZE_NOCRYPT; - /* Without encryption use the same offset as in Vim 7.2 to be compatible. - * With encryption it's OK to move elsewhere, the swap file is not - * compatible anyway. */ - if (*buf->b_p_key != NUL) - size = B0_FNAME_SIZE_CRYPT; - n = (int)STRLEN(buf->b_p_fenc); if ((int)STRLEN(b0p->b0_fname) + n + 1 > size) b0p->b0_flags &= ~B0_HAS_FENC; @@ -937,7 +780,6 @@ void ml_recover(void) ZERO_BL *b0p; int b0_ff; char_u *b0_fenc = NULL; - int b0_cm = -1; PTR_BL *pp; DATA_BL *dp; infoptr_T *ip; @@ -1013,7 +855,7 @@ void ml_recover(void) /* * Allocate a buffer structure for the swap file that is used for recovery. - * Only the memline and crypt information in it are really used. + * Only the memline in it is really used. */ buf = (buf_T *)alloc((unsigned)sizeof(buf_T)); @@ -1026,8 +868,6 @@ void ml_recover(void) buf->b_ml.ml_line_lnum = 0; /* no cached line */ buf->b_ml.ml_locked = NULL; /* no locked block */ buf->b_ml.ml_flags = 0; - buf->b_p_key = empty_option; - buf->b_p_cm = empty_option; /* * open the memfile from the old swap file @@ -1042,7 +882,6 @@ void ml_recover(void) goto theend; } buf->b_ml.ml_mfp = mfp; - mfp->mf_buffer = buf; /* * The page size set in mf_open() might be different from the page size @@ -1093,14 +932,6 @@ void ml_recover(void) goto theend; } - if (b0p->b0_id[1] == BLOCK0_ID1_C0) - b0_cm = 0; - else if (b0p->b0_id[1] == BLOCK0_ID1_C1) { - b0_cm = 1; - memmove(mfp->mf_seed, &b0p->b0_seed, MF_SEED_LEN); - } - set_crypt_method(buf, b0_cm); - /* * If we guessed the wrong page size, we have to recalculate the * highest block number in the file. @@ -1172,9 +1003,6 @@ void ml_recover(void) if (b0p->b0_flags & B0_HAS_FENC) { int fnsize = B0_FNAME_SIZE_NOCRYPT; - /* Use the same size as in add_b0_fenc(). */ - if (b0p->b0_id[1] != BLOCK0_ID1) - fnsize = B0_FNAME_SIZE_CRYPT; for (p = b0p->b0_fname + fnsize; p > b0p->b0_fname && p[-1] != NUL; --p) ; b0_fenc = vim_strnsave(p, (int)(b0p->b0_fname + fnsize - p)); @@ -1193,36 +1021,11 @@ void ml_recover(void) /* * Try reading the original file to obtain the values of 'fileformat', * 'fileencoding', etc. Ignore errors. The text itself is not used. - * When the file is encrypted the user is asked to enter the key. */ if (curbuf->b_ffname != NULL) orig_file_status = readfile(curbuf->b_ffname, NULL, (linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM, NULL, READ_NEW); - if (b0_cm >= 0) { - /* Need to ask the user for the crypt key. If this fails we continue - * without a key, will probably get garbage text. */ - if (*curbuf->b_p_key != NUL) { - smsg((char_u *)_("Swap file is encrypted: \"%s\""), fname_used); - MSG_PUTS(_( - "\nIf you entered a new crypt key but did not write the text file,")); - MSG_PUTS(_("\nenter the new crypt key.")); - MSG_PUTS(_( - "\nIf you wrote the text file after changing the crypt key press enter")); - MSG_PUTS(_("\nto use the same key for text file and swap file")); - } else - smsg((char_u *)_(need_key_msg), fname_used); - buf->b_p_key = get_crypt_key(FALSE, FALSE); - if (buf->b_p_key == NULL) - buf->b_p_key = curbuf->b_p_key; - else if (*buf->b_p_key == NUL) { - free(buf->b_p_key); - buf->b_p_key = curbuf->b_p_key; - } - if (buf->b_p_key == NULL) - buf->b_p_key = empty_option; - } - /* Use the 'fileformat' and 'fileencoding' as stored in the swap file. */ if (b0_ff != 0) set_fileformat(b0_ff - 1, OPT_LOCAL); @@ -1454,10 +1257,6 @@ void ml_recover(void) MSG_PUTS(_("\nYou may want to delete the .swp file now.\n\n")); cmdline_row = msg_row; } - if (*buf->b_p_key != NUL && STRCMP(curbuf->b_p_key, buf->b_p_key) != 0) { - MSG_PUTS(_("Using crypt key from swap file for the text file.\n")); - set_option_value((char_u *)"key", 0L, buf->b_p_key, OPT_LOCAL); - } redraw_curbuf_later(NOT_VALID); theend: @@ -1469,9 +1268,6 @@ theend: mf_close(mfp, FALSE); /* will also free(mfp->mf_fname) */ } if (buf != NULL) { - if (buf->b_p_key != curbuf->b_p_key) - free_string_option(buf->b_p_key); - free_string_option(buf->b_p_cm); free(buf->b_ml.ml_stack); free(buf); } @@ -3927,108 +3723,6 @@ void ml_setflags(buf_T *buf) } } -/* - * If "data" points to a data block encrypt the text in it and return a copy - * in allocated memory. - */ -char_u *ml_encrypt_data(memfile_T *mfp, char_u *data, off_t offset, unsigned size) -{ - DATA_BL *dp = (DATA_BL *)data; - char_u *head_end; - char_u *text_start; - char_u *new_data; - int text_len; - - if (dp->db_id != DATA_ID) - return data; - - new_data = xmalloc(size); - head_end = (char_u *)(&dp->db_index[dp->db_line_count]); - text_start = (char_u *)dp + dp->db_txt_start; - text_len = size - dp->db_txt_start; - - /* Copy the header and the text. */ - memmove(new_data, dp, head_end - (char_u *)dp); - - /* Encrypt the text. */ - crypt_push_state(); - ml_crypt_prepare(mfp, offset, FALSE); - crypt_encode(text_start, text_len, new_data + dp->db_txt_start); - crypt_pop_state(); - - /* Clear the gap. */ - if (head_end < text_start) - memset(new_data + (head_end - data), 0, text_start - head_end); - - return new_data; -} - -/* - * Decrypt the text in "data" if it points to a data block. - */ -void ml_decrypt_data(memfile_T *mfp, char_u *data, off_t offset, unsigned size) -{ - DATA_BL *dp = (DATA_BL *)data; - char_u *head_end; - char_u *text_start; - int text_len; - - if (dp->db_id == DATA_ID) { - head_end = (char_u *)(&dp->db_index[dp->db_line_count]); - text_start = (char_u *)dp + dp->db_txt_start; - text_len = dp->db_txt_end - dp->db_txt_start; - - if (head_end > text_start || dp->db_txt_start > size - || dp->db_txt_end > size) - return; /* data was messed up */ - - /* Decrypt the text in place. */ - crypt_push_state(); - ml_crypt_prepare(mfp, offset, TRUE); - crypt_decode(text_start, text_len); - crypt_pop_state(); - } -} - -/* - * Prepare for encryption/decryption, using the key, seed and offset. - */ -static void ml_crypt_prepare(memfile_T *mfp, off_t offset, int reading) -{ - buf_T *buf = mfp->mf_buffer; - char_u salt[50]; - int method; - char_u *key; - char_u *seed; - - if (reading && mfp->mf_old_key != NULL) { - /* Reading back blocks with the previous key/method/seed. */ - method = mfp->mf_old_cm; - key = mfp->mf_old_key; - seed = mfp->mf_old_seed; - } else { - method = get_crypt_method(buf); - key = buf->b_p_key; - seed = mfp->mf_seed; - } - - use_crypt_method = method; /* select pkzip or blowfish */ - if (method == 0) { - vim_snprintf((char *)salt, sizeof(salt), "%s%" PRId64 "", - key, (int64_t)offset); - crypt_init_keys(salt); - } else { - /* Using blowfish, add salt and seed. We use the byte offset of the - * block for the salt. */ - vim_snprintf((char *)salt, sizeof(salt), "%" PRId64, (int64_t)offset); - bf_key_init(key, salt, (int)STRLEN(salt)); - bf_cfb_init(seed, MF_SEED_LEN); - } -} - - - - #define MLCS_MAXL 800 /* max no of lines in chunk */ #define MLCS_MINL 400 /* should be half of MLCS_MAXL */ diff --git a/src/nvim/memline.h b/src/nvim/memline.h index 99f2638e72..704a98b20e 100644 --- a/src/nvim/memline.h +++ b/src/nvim/memline.h @@ -5,7 +5,6 @@ #include "nvim/func_attr.h" int ml_open(buf_T *buf); -void ml_set_crypt_key(buf_T *buf, char_u *old_key, int old_cm); void ml_setname(buf_T *buf); void ml_open_files(void); void ml_open_file(buf_T *buf); @@ -37,10 +36,6 @@ char_u *makeswapname(char_u *fname, char_u *ffname, buf_T *buf, char_u *dir_name); char_u *get_file_in_dir(char_u *fname, char_u *dname); void ml_setflags(buf_T *buf); -char_u *ml_encrypt_data(memfile_T *mfp, char_u *data, off_t offset, - unsigned size) FUNC_ATTR_NONNULL_RET; -void ml_decrypt_data(memfile_T *mfp, char_u *data, off_t offset, - unsigned size); long ml_find_line_or_offset(buf_T *buf, linenr_T lnum, long *offp); void goto_byte(long cnt); diff --git a/src/nvim/memory.c b/src/nvim/memory.c index b39c113f99..215eac2a33 100644 --- a/src/nvim/memory.c +++ b/src/nvim/memory.c @@ -6,7 +6,6 @@ #include "nvim/vim.h" #include "nvim/misc2.h" #include "nvim/file_search.h" -#include "nvim/blowfish.h" #include "nvim/buffer.h" #include "nvim/charset.h" #include "nvim/diff.h" diff --git a/src/nvim/misc2.c b/src/nvim/misc2.c index 1292bc8eb4..b9b68c5d0b 100644 --- a/src/nvim/misc2.c +++ b/src/nvim/misc2.c @@ -14,7 +14,6 @@ #include "nvim/vim.h" #include "nvim/misc2.h" #include "nvim/file_search.h" -#include "nvim/blowfish.h" #include "nvim/buffer.h" #include "nvim/charset.h" #include "nvim/diff.h" diff --git a/src/nvim/option.c b/src/nvim/option.c index b5f480870e..49abc62c89 100644 --- a/src/nvim/option.c +++ b/src/nvim/option.c @@ -37,7 +37,6 @@ #include "nvim/vim.h" #include "nvim/option.h" -#include "nvim/blowfish.h" #include "nvim/buffer.h" #include "nvim/charset.h" #include "nvim/diff.h" @@ -59,7 +58,6 @@ #include "nvim/misc1.h" #include "nvim/misc2.h" #include "nvim/keymap.h" -#include "nvim/crypt.h" #include "nvim/garray.h" #include "nvim/cursor_shape.h" #include "nvim/move.h" @@ -137,7 +135,6 @@ # define PV_INEX OPT_BUF(BV_INEX) #define PV_INF OPT_BUF(BV_INF) #define PV_ISK OPT_BUF(BV_ISK) -# define PV_KEY OPT_BUF(BV_KEY) # define PV_KMAP OPT_BUF(BV_KMAP) #define PV_KP OPT_BOTH(OPT_BUF(BV_KP)) # define PV_LISP OPT_BUF(BV_LISP) @@ -253,7 +250,6 @@ static char_u *p_indk; static char_u *p_fex; static int p_inf; static char_u *p_isk; -static char_u *p_key; static int p_lisp; static int p_ml; static int p_ma; @@ -583,10 +579,6 @@ static struct vimoption (char_u *)&p_cpo, PV_NONE, {(char_u *)CPO_VI, (char_u *)CPO_VIM} SCRIPTID_INIT}, - {"cryptmethod", "cm", P_STRING|P_ALLOCED|P_VI_DEF, - (char_u *)&p_cm, PV_CM, - {(char_u *)"zip", (char_u *)0L} - SCRIPTID_INIT}, {"cscopepathcomp", "cspc", P_NUM|P_VI_DEF|P_VIM, (char_u *)&p_cspc, PV_NONE, {(char_u *)0L, (char_u *)0L} SCRIPTID_INIT}, @@ -1009,10 +1001,6 @@ static struct vimoption {"joinspaces", "js", P_BOOL|P_VI_DEF|P_VIM, (char_u *)&p_js, PV_NONE, {(char_u *)TRUE, (char_u *)0L} SCRIPTID_INIT}, - {"key", NULL, P_STRING|P_ALLOCED|P_VI_DEF|P_NO_MKRC, - (char_u *)&p_key, PV_KEY, - {(char_u *)"", (char_u *)0L} - SCRIPTID_INIT}, {"keymap", "kmp", P_STRING|P_ALLOCED|P_VI_DEF|P_RBUF|P_RSTAT|P_NFNAME| P_PRI_MKRC, (char_u *)&p_keymap, PV_KMAP, @@ -1832,7 +1820,6 @@ static char *(p_ambw_values[]) = {"single", "double", NULL}; static char *(p_bg_values[]) = {"light", "dark", NULL}; static char *(p_nf_values[]) = {"octal", "hex", "alpha", NULL}; static char *(p_ff_values[]) = {FF_UNIX, FF_DOS, FF_MAC, NULL}; -static char *(p_cm_values[]) = {"zip", "blowfish", NULL}; static char *(p_wop_values[]) = {"tagfile", NULL}; static char *(p_wak_values[]) = {"yes", "menu", "no", NULL}; static char *(p_mousem_values[]) = @@ -3596,9 +3583,7 @@ void check_buf_options(buf_T *buf) check_string_option(&buf->b_p_inex); check_string_option(&buf->b_p_inde); check_string_option(&buf->b_p_indk); - check_string_option(&buf->b_p_cm); check_string_option(&buf->b_p_fex); - check_string_option(&buf->b_p_key); check_string_option(&buf->b_p_kp); check_string_option(&buf->b_p_mps); check_string_option(&buf->b_p_fo); @@ -4135,59 +4120,7 @@ did_set_string_option ( errmsg = e_invarg; } } - /* 'cryptkey' */ - else if (gvarp == &p_key) { - /* Make sure the ":set" command doesn't show the new value in the - * history. */ - remove_key_from_history(); - if (STRCMP(curbuf->b_p_key, oldval) != 0) - /* Need to update the swapfile. */ - ml_set_crypt_key(curbuf, oldval, get_crypt_method(curbuf)); - } else if (gvarp == &p_cm) { - if (opt_flags & OPT_LOCAL) - p = curbuf->b_p_cm; - else - p = p_cm; - if (check_opt_strings(p, p_cm_values, TRUE) != OK) - errmsg = e_invarg; - else if (get_crypt_method(curbuf) > 0 && blowfish_self_test() == FAIL) - errmsg = e_invarg; - else { - /* When setting the global value to empty, make it "zip". */ - if (*p_cm == NUL) { - if (new_value_alloced) - free_string_option(p_cm); - p_cm = vim_strsave((char_u *)"zip"); - new_value_alloced = TRUE; - } - /* Need to update the swapfile when the effective method changed. - * Set "s" to the effective old value, "p" to the effective new - * method and compare. */ - if ((opt_flags & OPT_LOCAL) && *oldval == NUL) - s = p_cm; /* was previously using the global value */ - else - s = oldval; - if (*curbuf->b_p_cm == NUL) - p = p_cm; /* is now using the global value */ - else - p = curbuf->b_p_cm; - if (STRCMP(s, p) != 0) - ml_set_crypt_key(curbuf, curbuf->b_p_key, - crypt_method_from_string(s)); - - /* If the global value changes need to update the swapfile for all - * buffers using that value. */ - if ((opt_flags & OPT_GLOBAL) && STRCMP(p_cm, oldval) != 0) { - buf_T *buf; - - for (buf = firstbuf; buf != NULL; buf = buf->b_next) - if (buf != curbuf && *buf->b_p_cm == NUL) - ml_set_crypt_key(buf, buf->b_p_key, - crypt_method_from_string(oldval)); - } - } - } /* 'matchpairs' */ else if (gvarp == &p_mps) { if (has_mbyte) { @@ -5923,12 +5856,7 @@ get_option_value ( if (varp == NULL) /* hidden option */ return -2; if (stringval != NULL) { - /* never return the value of the crypt key */ - if ((char_u **)varp == &curbuf->b_p_key - && **(char_u **)(varp) != NUL) - *stringval = vim_strsave((char_u *)"*****"); - else - *stringval = vim_strsave(*(char_u **)(varp)); + *stringval = vim_strsave(*(char_u **)(varp)); } return 0; } @@ -6756,7 +6684,6 @@ static char_u *get_varp_scope(struct vimoption *p, int opt_flags) case PV_INC: return (char_u *)&(curbuf->b_p_inc); case PV_DICT: return (char_u *)&(curbuf->b_p_dict); case PV_TSR: return (char_u *)&(curbuf->b_p_tsr); - case PV_CM: return (char_u *)&(curbuf->b_p_cm); case PV_STL: return (char_u *)&(curwin->w_p_stl); case PV_UL: return (char_u *)&(curbuf->b_p_ul); } @@ -6802,8 +6729,6 @@ static char_u *get_varp(struct vimoption *p) ? (char_u *)&(curbuf->b_p_gp) : p->var; case PV_MP: return *curbuf->b_p_mp != NUL ? (char_u *)&(curbuf->b_p_mp) : p->var; - case PV_CM: return *curbuf->b_p_cm != NUL - ? (char_u *)&(curbuf->b_p_cm) : p->var; case PV_STL: return *curwin->w_p_stl != NUL ? (char_u *)&(curwin->w_p_stl) : p->var; case PV_UL: return curbuf->b_p_ul != NO_LOCAL_UNDOLEVEL @@ -6873,7 +6798,6 @@ static char_u *get_varp(struct vimoption *p) case PV_INDE: return (char_u *)&(curbuf->b_p_inde); case PV_INDK: return (char_u *)&(curbuf->b_p_indk); case PV_FEX: return (char_u *)&(curbuf->b_p_fex); - case PV_KEY: return (char_u *)&(curbuf->b_p_key); case PV_LISP: return (char_u *)&(curbuf->b_p_lisp); case PV_ML: return (char_u *)&(curbuf->b_p_ml); case PV_MPS: return (char_u *)&(curbuf->b_p_mps); @@ -7135,7 +7059,6 @@ void buf_copy_options(buf_T *buf, int flags) buf->b_p_inde = vim_strsave(p_inde); buf->b_p_indk = vim_strsave(p_indk); buf->b_p_fex = vim_strsave(p_fex); - buf->b_p_key = vim_strsave(p_key); buf->b_p_sua = vim_strsave(p_sua); buf->b_p_keymap = vim_strsave(p_keymap); buf->b_kmap_state |= KEYMAP_INIT; @@ -7161,7 +7084,6 @@ void buf_copy_options(buf_T *buf, int flags) buf->b_p_dict = empty_option; buf->b_p_tsr = empty_option; buf->b_p_qe = vim_strsave(p_qe); - buf->b_p_cm = empty_option; buf->b_p_udf = p_udf; /* @@ -7620,9 +7542,6 @@ option_value2string ( varp = *(char_u **)(varp); if (varp == NULL) /* just in case */ NameBuff[0] = NUL; - /* don't show the actual value of 'key', only that it's set */ - else if (opp->var == (char_u *)&p_key && *varp) - STRCPY(NameBuff, "*****"); else if (opp->flags & P_EXPAND) home_replace(NULL, varp, NameBuff, MAXPATHL, FALSE); /* Translate 'pastetoggle' into special key names */ diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h index 3cb96e46a8..ae08b1fa5f 100644 --- a/src/nvim/option_defs.h +++ b/src/nvim/option_defs.h @@ -308,7 +308,6 @@ static char *(p_bkc_values[]) = EXTERN char_u *p_bdir; /* 'backupdir' */ EXTERN char_u *p_bex; /* 'backupext' */ EXTERN char_u *p_bsk; /* 'backupskip' */ -EXTERN char_u *p_cm; /* 'cryptmethod' */ EXTERN char_u *p_breakat; /* 'breakat' */ EXTERN char_u *p_cmp; /* 'casemap' */ EXTERN unsigned cmp_flags; @@ -688,7 +687,6 @@ enum { , BV_INEX , BV_INF , BV_ISK - , BV_KEY , BV_KMAP , BV_KP , BV_LISP diff --git a/src/nvim/sha256.c b/src/nvim/sha256.c index 549448a6e0..4a61ddc66f 100644 --- a/src/nvim/sha256.c +++ b/src/nvim/sha256.c @@ -9,7 +9,6 @@ /// /// Vim specific notes: /// Functions exported by this file: -/// 1. sha256_key() hashes the password to 64 bytes char string. /// 2. sha2_seed() generates a random header. /// sha256_self_test() is implicitly called once. @@ -284,23 +283,6 @@ char_u *sha256_bytes(char_u *buf, int buf_len, char_u *salt, int salt_len) return hexit; } -/// Gets sha256(buf) as 64 hex characters in a static array. -/// -/// @param buf -/// @param salt -/// @param salt_len -/// -/// @returns sha256(buf) as 64 hex chars in static array. -char_u* sha256_key(char_u *buf, char_u *salt, int salt_len) -{ - // No passwd means don't encrypt - if ((buf == NULL) || (*buf == NUL)) { - return (char_u *)""; - } - - return sha256_bytes(buf, (int)STRLEN(buf), salt, salt_len); -} - // These are the standard FIPS-180-2 test vectors static char *sha_self_test_msg[] = { "abc", diff --git a/src/nvim/sha256.h b/src/nvim/sha256.h index 0df4746167..355b758cdd 100644 --- a/src/nvim/sha256.h +++ b/src/nvim/sha256.h @@ -11,7 +11,6 @@ void sha256_start(context_sha256_T *ctx); void sha256_update(context_sha256_T *ctx, char_u *input, uint32_t length); void sha256_finish(context_sha256_T *ctx, char_u digest[32]); char_u *sha256_bytes(char_u *buf, int buf_len, char_u *salt, int salt_len); -char_u *sha256_key(char_u *buf, char_u *salt, int salt_len); int sha256_self_test(void); void sha2_seed(char_u *header, int header_len, char_u *salt, int salt_len); diff --git a/src/nvim/spell.c b/src/nvim/spell.c index 0f35681546..6b229f7498 100644 --- a/src/nvim/spell.c +++ b/src/nvim/spell.c @@ -7731,7 +7731,6 @@ static buf_T *open_spellbuf(void) buf->b_spell = TRUE; buf->b_p_swf = TRUE; // may create a swap file - buf->b_p_key = empty_option; ml_open(buf); ml_open_file(buf); // create swap file now diff --git a/src/nvim/strings.c b/src/nvim/strings.c index fbad71e3c6..50669dfcfb 100644 --- a/src/nvim/strings.c +++ b/src/nvim/strings.c @@ -4,7 +4,6 @@ #include "nvim/strings.h" #include "nvim/misc2.h" #include "nvim/file_search.h" -#include "nvim/blowfish.h" #include "nvim/buffer.h" #include "nvim/charset.h" #include "nvim/diff.h" diff --git a/src/nvim/testdir/test71.in b/src/nvim/testdir/test71.in deleted file mode 100644 index 155fd413bc..0000000000 --- a/src/nvim/testdir/test71.in +++ /dev/null @@ -1,67 +0,0 @@ -Test for encryption. -The test data is in another file to avoid problems with 'encoding', especially -cp932. - -STARTTEST -:so small.vim -:set enc=latin1 -:bwipe! -:r test71a.in -:/^start of text/+1 -:let text_lines = getline('.', line('.') + 2) -:/^start of cm=zip bytes/+1 -:let cm0_bytes = getline('.', '.') -:/^start of cm=blowfish bytes/+1 -:let cm1_bytes = getline('.', '.') -:bwipe! -:call append(0, text_lines) -:$d -:X -foobar -foobar -:w! Xtestfile -:bwipe! -:e Xtestfile -foobar -:let cm0_read_back = getline('.', '$') -:set key= -:set cryptmethod=blowfish -:" If the blowfish test fails 'cryptmethod' will be 'zip' now. -:%s/^/\=&cryptmethod == 'blowfish' ? "OK " : "blowfish test failed "/ -:X -barfoo -barfoo -:w! Xtestfile -:bwipe! -:e Xtestfile -barfoo -:let cm1_read_back = getline('.', '$') -:bwipe! -:set bin noeol key= -:call append(0, cm0_bytes) -:$d -:set fenc=latin1 -:w! Xtestfile -:bwipe! -:set nobin -:e Xtestfile -foofoo -:let cm0_read_bin = getline('.', '$') -:bwipe! -:set bin noeol key= -:call append(0, cm1_bytes) -:$d -:set fenc=latin1 -:w! Xtestfile -:bwipe! -:set nobin -:e Xtestfile -barbar -:call append(0, cm0_read_bin) -:call append(0, cm1_read_back) -:call append(0, cm0_read_back) -:set key= fenc=latin1 -:w! test.out -:qa! -ENDTEST - diff --git a/src/nvim/testdir/test71.ok b/src/nvim/testdir/test71.ok deleted file mode 100644 index 24652c4380..0000000000 --- a/src/nvim/testdir/test71.ok +++ /dev/null @@ -1,10 +0,0 @@ -01234567890123456789012345678901234567 -line 2 foo bar blah -line 3 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx -OK 01234567890123456789012345678901234567 -OK line 2 foo bar blah -OK line 3 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx -1234567890 -aábbccddeëff -asdfasdfasdf -0001112223333 diff --git a/src/nvim/testdir/test71a.in b/src/nvim/testdir/test71a.in deleted file mode 100644 index 85bd22cd01..0000000000 --- a/src/nvim/testdir/test71a.in +++ /dev/null @@ -1,14 +0,0 @@ - -start of text -01234567890123456789012345678901234567 -line 2 foo bar blah -line 3 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx -end of text - -start of cm=zip bytes -VimCrypt~01! lV'Þ}Mg ê£V©çE#3Ž2Ué— -end of cm=zip bytes - -start of cm=blowfish bytes -VimCrypt~02!k)¾—#ÝSœõ=ºàÈ#¥M´†JÃAÍ¥M´†!€›õáÒ‚˜÷
Ú -end of cm=blowfish bytes diff --git a/src/nvim/testdir/test72.in b/src/nvim/testdir/test72.in index 220adad67a..0821764c3c 100644 --- a/src/nvim/testdir/test72.in +++ b/src/nvim/testdir/test72.in @@ -57,52 +57,6 @@ i u:e! Xtestfile :set undofile ul=100 uuuuuu:w >>test.out -:" And now with encryption, cryptmethod=zip -:e! Xtestfile -:set undofile cm=zip -ggdGimonday -tuesday -wednesday -thursday -friday:set ul=100 -kkkdd:set ul=100 -dd:set ul=100 -dd:set ul=100 -:X -foobar -foobar -:w! -:bwipe! -:e Xtestfile -foobar -:set key= -uu:w >>test.out -:" -:" -:" With encryption, cryptmethod=blowfish -:e! Xtestfile -:set undofile cm=blowfish -ggdGijan -feb -mar -apr -jun:set ul=100 -kk0ifoo :set ul=100 -dd:set ul=100 -ibar :set ul=100 -:X -foobar -foobar -:w! -:bwipe! -:e Xtestfile -foobar -:set key= -/bar -:.w >>test.out -u:.w >>test.out -u:.w >>test.out -u:.w >>test.out :" :" Rename the undo file so that it gets cleaned up. :call rename(".Xtestfile.un~", "Xtestundo") diff --git a/src/nvim/testdir/test72.ok b/src/nvim/testdir/test72.ok index bb267d0d8b..091b1e94a6 100644 --- a/src/nvim/testdir/test72.ok +++ b/src/nvim/testdir/test72.ok @@ -17,11 +17,3 @@ seven eight nine ten -monday -wednesday -thursday -friday -bar apr -apr -foo mar -mar diff --git a/src/nvim/undo.c b/src/nvim/undo.c index 4d499cc28e..844ade790f 100644 --- a/src/nvim/undo.c +++ b/src/nvim/undo.c @@ -94,7 +94,6 @@ #include "nvim/misc1.h" #include "nvim/misc2.h" #include "nvim/memory.h" -#include "nvim/crypt.h" #include "nvim/garray.h" #include "nvim/option.h" #include "nvim/os_unix.h" @@ -121,9 +120,6 @@ static void u_freeentries(buf_T *buf, u_header_T *uhp, static void u_freeentry(u_entry_T *, long); static void corruption_error(char *mesg, char_u *file_name); static void u_free_uhp(u_header_T *uhp); -static size_t fwrite_crypt(buf_T *buf, char_u *ptr, size_t len, - FILE *fp); -static char_u *read_string_decrypt(buf_T *buf, FILE *fd, int len); static int serialize_header(FILE *fp, buf_T *buf, char_u *hash); static int serialize_uhp(FILE *fp, buf_T *buf, u_header_T *uhp); static u_header_T *unserialize_uhp(FILE *fp, char_u *file_name); @@ -634,7 +630,6 @@ nomem: # define UF_ENTRY_MAGIC 0xf518 /* magic at start of entry */ # define UF_ENTRY_END_MAGIC 0x3581 /* magic after last entry */ # define UF_VERSION 2 /* 2-byte undofile version number */ -# define UF_VERSION_CRYPT 0x8002 /* idem, encrypted */ /* extra fields for header */ # define UF_LAST_SAVE_NR 1 @@ -753,44 +748,6 @@ static void u_free_uhp(u_header_T *uhp) free(uhp); } -/* - * Like fwrite() but crypt the bytes when 'key' is set. - * Returns 1 if successful. - */ -static size_t fwrite_crypt(buf_T *buf, char_u *ptr, size_t len, FILE *fp) -{ - char_u *copy; - char_u small_buf[100]; - size_t i; - - if (*buf->b_p_key == NUL) - return fwrite(ptr, len, (size_t)1, fp); - if (len < 100) - copy = small_buf; /* no malloc()/free() for short strings */ - else { - copy = xmalloc(len); - } - crypt_encode(ptr, len, copy); - i = fwrite(copy, len, (size_t)1, fp); - if (copy != small_buf) - free(copy); - return i; -} - -/* - * Read a string of length "len" from "fd". - * When 'key' is set decrypt the bytes. - */ -static char_u *read_string_decrypt(buf_T *buf, FILE *fd, int len) -{ - char_u *ptr; - - ptr = read_string(fd, len); - if (ptr != NULL && *buf->b_p_key != NUL) - crypt_decode(ptr, len); - return ptr; -} - static int serialize_header(FILE *fp, buf_T *buf, char_u *hash) { int len; @@ -799,25 +756,7 @@ static int serialize_header(FILE *fp, buf_T *buf, char_u *hash) if (fwrite(UF_START_MAGIC, (size_t)UF_START_MAGIC_LEN, (size_t)1, fp) != 1) return FAIL; - /* If the buffer is encrypted then all text bytes following will be - * encrypted. Numbers and other info is not crypted. */ - if (*buf->b_p_key != NUL) { - char_u *header; - int header_len; - - put_bytes(fp, (long_u)UF_VERSION_CRYPT, 2); - header = prepare_crypt_write(buf, &header_len); - if (header == NULL) - return FAIL; - len = (int)fwrite(header, (size_t)header_len, (size_t)1, fp); - free(header); - if (len != 1) { - crypt_pop_state(); - return FAIL; - } - } else - put_bytes(fp, (long_u)UF_VERSION, 2); - + put_bytes(fp, (long_u)UF_VERSION, 2); /* Write a hash of the buffer text, so that we can verify it is still the * same when reading the buffer text. */ @@ -828,7 +767,7 @@ static int serialize_header(FILE *fp, buf_T *buf, char_u *hash) put_bytes(fp, (long_u)buf->b_ml.ml_line_count, 4); len = buf->b_u_line_ptr != NULL ? (int)STRLEN(buf->b_u_line_ptr) : 0; put_bytes(fp, (long_u)len, 4); - if (len > 0 && fwrite_crypt(buf, buf->b_u_line_ptr, (size_t)len, fp) != 1) + if (len > 0 && fwrite(buf->b_u_line_ptr, len, 1, fp) != 1) return FAIL; put_bytes(fp, (long_u)buf->b_u_line_lnum, 4); put_bytes(fp, (long_u)buf->b_u_line_colnr, 4); @@ -982,7 +921,7 @@ static int serialize_uep(FILE *fp, buf_T *buf, u_entry_T *uep) len = STRLEN(uep->ue_array[i]); if (put_bytes(fp, (long_u)len, 4) == FAIL) return FAIL; - if (len > 0 && fwrite_crypt(buf, uep->ue_array[i], len, fp) != 1) + if (len > 0 && fwrite(uep->ue_array[i], len, 1, fp) != 1) return FAIL; } return OK; @@ -1015,7 +954,7 @@ static u_entry_T *unserialize_uep(FILE *fp, int *error, char_u *file_name) for (i = 0; i < uep->ue_size; ++i) { line_len = get4c(fp); if (line_len >= 0) - line = read_string_decrypt(curbuf, fp, line_len); + line = read_string(fp, line_len); else { line = NULL; corruption_error("line length", file_name); @@ -1107,7 +1046,6 @@ void u_write_undo(char_u *name, int forceit, buf_T *buf, char_u *hash) FILE *fp = NULL; int perm; int write_ok = FALSE; - int do_crypt = FALSE; if (name == NULL) { file_name = u_get_undo_file_name(buf->b_ffname, FALSE); @@ -1245,8 +1183,6 @@ void u_write_undo(char_u *name, int forceit, buf_T *buf, char_u *hash) */ if (serialize_header(fp, buf, hash) == FAIL) goto write_error; - if (*buf->b_p_key != NUL) - do_crypt = TRUE; /* * Iteratively serialize UHPs and their UEPs from the top down. @@ -1305,8 +1241,6 @@ write_error: #endif theend: - if (do_crypt) - crypt_pop_state(); if (file_name != name) free(file_name); } @@ -1343,7 +1277,6 @@ void u_read_undo(char_u *name, char_u *hash, char_u *orig_name) #ifdef U_DEBUG int *uhp_table_used; #endif - int do_decrypt = FALSE; if (name == NULL) { file_name = u_get_undo_file_name(curbuf->b_ffname, TRUE); @@ -1393,18 +1326,7 @@ void u_read_undo(char_u *name, char_u *hash, char_u *orig_name) goto error; } version = get2c(fp); - if (version == UF_VERSION_CRYPT) { - if (*curbuf->b_p_key == NUL) { - EMSG2(_("E832: Non-encrypted file has encrypted undo file: %s"), - file_name); - goto error; - } - if (prepare_crypt_read(fp) == FAIL) { - EMSG2(_("E826: Undo file decryption failed: %s"), file_name); - goto error; - } - do_decrypt = TRUE; - } else if (version != UF_VERSION) { + if (version != UF_VERSION) { EMSG2(_("E824: Incompatible undo file: %s"), file_name); goto error; } @@ -1432,7 +1354,7 @@ void u_read_undo(char_u *name, char_u *hash, char_u *orig_name) if (str_len < 0) goto error; if (str_len > 0) - line_ptr = read_string_decrypt(curbuf, fp, str_len); + line_ptr = read_string(fp, str_len); line_lnum = (linenr_T)get4c(fp); line_colnr = (colnr_T)get4c(fp); if (line_lnum < 0 || line_colnr < 0) { @@ -1602,8 +1524,6 @@ error: } theend: - if (do_decrypt) - crypt_pop_state(); if (fp != NULL) fclose(fp); if (file_name != name) diff --git a/src/nvim/version.c b/src/nvim/version.c index a140453c96..bab38a8d32 100644 --- a/src/nvim/version.c +++ b/src/nvim/version.c @@ -54,7 +54,6 @@ static char *(features[]) = { "+cmdline_info", "+comments", "+conceal", - "+cryptv", "+cscope", "+cursorbind", #ifdef CURSOR_SHAPE |