Update encoder files after nodemcu#925 & nodemcu#1072 review comments

app/modules/crypto.c

@@ -38,7 +38,7 @@ static int crypto_sha1( lua_State* L )
 }
 
 #ifdef LUA_USE_MODULES_ENCODER
-static int call_endcoder( lua_State* L, const char *function ) {
+static int call_encoder( lua_State* L, const char *function ) {
   if (lua_gettop(L) != 1) { 
     luaL_error(L, "%s must have one argument", function);
   }
@@ -54,10 +54,10 @@ static int call_endcoder( lua_State* L, const char *function ) {
 }
 
 static int crypto_base64_encode (lua_State* L) { 
-  return call_endcoder(L, "toBase64"); 
+  return call_encoder(L, "toBase64"); 
 }
 static int crypto_hex_encode (lua_State* L) { 
-  return call_endcoder(L, "toHex"); 
+  return call_encoder(L, "toHex"); 
 }
 #else
 static const char* bytes64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

app/modules/encoder.c

@@ -8,16 +8,16 @@
 #define BASE64_PADDING '='
 #define ISBASE64(c) (unbytes64[c] != BASE64_INVALID)
 
-static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const uint8 b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-static char *toBase64 ( lua_State* L, const char *msg, size_t *len){
+static uint8 *toBase64 ( lua_State* L, const uint8 *msg, size_t *len){
   size_t i, n = *len;
 
   if (!n)  // handle empty string case 
     return NULL;
 
-  char* q, *out = (char*)luaM_malloc(L, (n + 2) / 3 * 4);
-  char bytes64[sizeof(b64)];
+  uint8 * q, *out = (uint8 *)luaM_malloc(L, (n + 2) / 3 * 4);
+  uint8 bytes64[sizeof(b64)];
   c_memcpy(bytes64, b64, sizeof(b64));   //Avoid lots of flash unaligned fetches
 
   for (i = 0, q = out; i < n; i += 3) {
@@ -33,51 +33,56 @@ static char *toBase64 ( lua_State* L, const char *msg, size_t *len){
   return out;
 }
 
-static char *fromBase64 ( lua_State* L, const char *enc_msg, size_t *len){
-  int i, n = *len, pad = 0;
-  unsigned const char *p;
-  unsigned char unbytes64[CHAR_MAX+1-CHAR_MIN], *msg, *q, a, b, c, d;
+static uint8 *fromBase64 ( lua_State* L, const uint8 *enc_msg, size_t *len){
+  int i, n = *len, blocks = (n>>2), pad = 0;
+  const uint8 *p;
+  uint8 unbytes64[UCHAR_MAX+1], *msg, *q;
 
   if (!n)  // handle empty string case 
     return NULL;
 
-  if (n % 4)
+  if (n & 3)
     luaL_error (L, "Invalid base64 string"); 
 
   c_memset(unbytes64, BASE64_INVALID, sizeof(unbytes64));
   for (i = 0; i < sizeof(b64)-1; i++) unbytes64[b64[i]] = i;  // sequential so no exceptions 
 
   if (enc_msg[n-1] == BASE64_PADDING) {
     pad =  (enc_msg[n-2] != BASE64_PADDING) ? 1 : 2;
+    blocks--;  //exclude padding block
   }    
 
  for (i = 0; i < n - pad; i++) if (!ISBASE64(enc_msg[i])) luaL_error (L, "Invalid base64 string");
   unbytes64[BASE64_PADDING] = 0;
 
-  msg = q = (unsigned char*) luaM_malloc(L, 1+ (3 * n / 4)); 
-  for (i = 0, p = (unsigned char*) enc_msg;; i+=4)  {
-    a = unbytes64[*p++], b = unbytes64[*p++], c = unbytes64[*p++], d = unbytes64[*p++] ;
-    if (i > n-4) break;
+  msg = q = (uint8 *) luaM_malloc(L, 1+ (3 * n / 4)); 
+  for (i = 0, p = enc_msg; i<blocks; i++)  {
+    uint8 a = unbytes64[*p++]; 
+    uint8 b = unbytes64[*p++]; 
+    uint8 c = unbytes64[*p++]; 
+    uint8 d = unbytes64[*p++];
     *q++ = (a << 2) | (b >> 4);
     *q++ = (b << 4) | (c >> 2);
     *q++ = (c << 6) | d;
   }
 
-  if (pad) {
+  if (pad) { //now process padding block bytes
+    uint8 a = unbytes64[*p++];
+    uint8 b = unbytes64[*p++];
     *q++ = (a << 2) | (b >> 4);
-    if (pad == 1) *q++ = (b << 4) | (c >> 2);
+    if (pad == 1) *q++ = (b << 4) | (unbytes64[*p] >> 2);
   }
   *len = q - msg;
-  return (char *) msg;
+  return msg;
 }
 
-static inline char to_hex_nibble(unsigned char b) {
+static inline uint8 to_hex_nibble(uint8 b) {
   return b + ( b < 10 ? '0' : 'a' - 10 );
   }
 
-static char *toHex ( lua_State* L, const char *msg, size_t *len){
+static uint8 *toHex ( lua_State* L, const uint8 *msg, size_t *len){
   int i, n = *len;
-  char *q, *out = (char*)luaM_malloc(L, n * 2);
+  uint8 *q, *out = (uint8 *)luaM_malloc(L, n * 2);
   for (i = 0, q = out; i < n; i++) {
     *q++ = to_hex_nibble(msg[i] >> 4);
     *q++ = to_hex_nibble(msg[i] & 0xf);
@@ -86,11 +91,11 @@ static char *toHex ( lua_State* L, const char *msg, size_t *len){
   return out;
 }
 
-static char *fromHex ( lua_State* L, const char *msg, size_t *len){
+static uint8 *fromHex ( lua_State* L, const uint8 *msg, size_t *len){
   int i, n = *len;
-  const char *p;
-  char b, *q, *out = (char*)luaM_malloc(L, n * 2);
-  unsigned char c;
+  const uint8 *p;
+  uint8 b, *q, *out = (uint8 *)luaM_malloc(L, n * 2);
+  uint8 c;
 
   if (n &1)
     luaL_error (L, "Invalid hex string");
@@ -118,12 +123,12 @@ static char *fromHex ( lua_State* L, const char *msg, size_t *len){
 // All encoder functions are of the form:
 // Lua:  output_string = encoder.function(input_string) 
 // Where input string maybe empty, but not nil
-// Hence these all chare the do_func wrapper
-static int do_func (lua_State *L, char * (*conv_func)(lua_State *, const char *, size_t *)) {
+// Hence these all call the do_func wrapper
+static int do_func (lua_State *L, uint8 * (*conv_func)(lua_State *, const uint8 *, size_t *)) {
   size_t l;
-  const char *input = luaL_checklstring(L, 1, &l);
+  const uint8 *input = luaL_checklstring(L, 1, &l);
 //  luaL_argcheck(L, l>0, 1, "input string empty");
-  char *output = conv_func(L, input, &l);
+  uint8 *output = conv_func(L, input, &l);
 
   if (output) {
     lua_pushlstring(L, output, l);

docs/en/modules/encoder.md

@@ -17,12 +17,13 @@ A Base64 encoded string.
 
 #### Example
 ```lua
-print(encoder.toBase64(cyrpto.hash("sha1","abc")))
+print(encoder.toBase64(crypto.hash("sha1","abc")))
 ```
 
 ## encoder.fromBase64()
 
-Decodes a Base64 representation of a (binary) Lua string back into the original string.
+Decodes a Base64 representation of a (binary) Lua string back into the original string.  An error is
+thrown if the string is not a valid base64 encoding.
 
 #### Syntax
 `binary_string = encoder.toBase64(b64)`
@@ -40,7 +41,8 @@ print(encoder.fromBase64(encoder.toBase64("hello world")))
 
 ## encoder.toHex()
 
-Provides an ASCII hex representation of a (binary) Lua string. Each byte in the input string is represented as two hex characters in the output.
+Provides an ASCII hex representation of a (binary) Lua string. Each byte in the input string is
+represented as two hex characters in the output.
 
 #### Syntax
 `hexstr = encoder.toHex(binary)`
@@ -58,10 +60,12 @@ print(encoder.toHex(crypto.hash("sha1","abc")))
 
 ## encoder.fromHex()
 
-Provides a Lua binary string decode of a ASCII hex string. Each byte in the output string is represented as two hex characters in the input.
+Returns the Lua binary string decode of a ASCII hex string. Each byte in the output string is
+represented as two hex characters in the input.  An error is thrown if the string is not a 
+valid base64 encoding.
 
 #### Syntax
-`binary = encoder.toHex(hexstr)`
+`binary = encoder.fromHex(hexstr)`
 
 #### Parameters
 `hexstr`  An ASCII hex string.