inline void ParseAuthNameAndPassword(StrPtrLen *codedStrPtr, StrPtrLen* namePtr, StrPtrLen* passwordPtr) { if (!codedStrPtr || (codedStrPtr->Len >= kAuthNameAndPasswordBuffSize) ) { return; } StrPtrLen codedLineStr; StrPtrLen nameAndPassword; memset(decodedLine,0,kAuthNameAndPasswordBuffSize); memset(codedLine,0,kAuthNameAndPasswordBuffSize); memcpy (codedLine,codedStrPtr->Ptr,codedStrPtr->Len); codedLineStr.Set((char*) codedLine, codedStrPtr->Len); (void) Base64decode(decodedLine, codedLineStr.Ptr); nameAndPassword.Set((char*) decodedLine, strlen(decodedLine)); StringParser parsedNameAndPassword(&nameAndPassword); parsedNameAndPassword.ConsumeUntil(namePtr,':'); parsedNameAndPassword.ConsumeLength(NULL, 1); // password can have whitespace, so read until the end of the line, not just until whitespace parsedNameAndPassword.ConsumeUntil(passwordPtr, StringParser::sEOLMask); namePtr->Ptr[namePtr->Len]= 0; passwordPtr->Ptr[passwordPtr->Len]= 0; //qtss_printf("decoded nameAndPassword="******"decoded name="); PRINT_STR(namePtr); //qtss_printf("decoded password="); PRINT_STR(passwordPtr); return; };
int CACrypto::decodeBase64(const char* input, char* output, int outputBufferLength) { CCAssert(Base64decode_len(input) <= outputBufferLength, "CACrypto::decodeBase64() - outputBufferLength too small"); return Base64decode(output, input); }
LUA_STRING Crypto::encodingBase64Lua(bool isDecoding, const char* input, int inputLength) { LuaStack* stack = LuaEngine::getInstance()->getLuaStack(); stack->clean(); int bufferSize = isDecoding ? Base64decode_len(input) : Base64encode_len(inputLength); char *buffer = bufferSize ? (char*)malloc(bufferSize) : NULL; int size = 0; if (buffer) { size = isDecoding ? Base64decode(buffer, input) : Base64encode(buffer, input, inputLength); } if (size) { stack->pushString(buffer, size); } else { stack->pushNil(); } if (buffer) { free(buffer); } return 1; }
int main () { char *B64Text = "HUIfTQsPAh9PE048GmllH0kcDk4TAQsHThsBFkU2AB4BSWQgVB0dQzNTTmVSBgBHVBwNRU0HBAxTEjwMHghJGgkRTxRMIRpHKwAFHUdZEQQJAGQmB1MANxYGDBoXQR0BUlQwXwAgEwoFR0$"; char *buf = malloc(Base64decode_len(B64Text)); Base64decode(buf, B64Text); RepeatedXorAnalysis(buf, Base64decode_len(B64Text) - 1); }
/* Decodes binary data from a file. */ static c4snet_data_t *C4SNetDecode(FILE *file) { c4snet_data_t *c = SNetMemAlloc(sizeof(c4snet_data_t)); Base64decodeDataType(file, (int*) &c->vtype); Base64decode(file, &c->size, sizeof(int)); Base64decodeDataType(file, (int*) &c->type); c->ref_count = 1; if(c->vtype == VTYPE_array) { c->data.ptr = MemAlloc(AllocatedSpace(c)); Base64decode(file, c->data.ptr, AllocatedSpace(c)); } else { Base64decode(file, &c->data, C4SNetSizeof(c)); } return c; }
int main(int argc, char** argv) { const char encoded[300] = "eyJWZXIiOjEsICJJRCI6MSwgIlRzdGFtcCI6MTQ0MzcwMDkxNSwgIlJzdGF0ZSI6Ik9OIiwgIlZzdGF0ZSI6Ik9QRU4iLCAiR3N0YXRlIjoiT0siLCAiVDEiOjU0LCAiVDIiOjI5LCAiVDMiOjE0LCAiVDQiOjI1LCAiS1ciOjAuMywgIktXSCI6MC4wLCAiSExtaW4iOjAuMCwgIkhMdG90YWwiOjAuMCwgIkNMbWluIjowLjAsICJDTHRvdGFsIjowLjB9"; char decode[300]; printf("%s\n", encoded); Base64decode(decode, "eyJWZXIiOjEsICJJRCI6MSwgIlRzdGFtcCI6MTQ0MzcwMDkxNSwgIlJzdGF0ZSI6Ik9OIiwgIlZzdGF0ZSI6Ik9QRU4iLCAiR3N0YXRlIjoiT0siLCAiVDEiOjU0LCAiVDIiOjI5LCAiVDMiOjE0LCAiVDQiOjI1LCAiS1ciOjAuMywgIktXSCI6MC4wLCAiSExtaW4iOjAuMCwgIkhMdG90YWwiOjAuMCwgIkNMbWluIjowLjAsICJDTHRvdGFsIjowLjB9"); printf("%s\n", decode); return 0; }
/* * Signature: ([B)[B */ static jbyteArray Base64Decode(JNIEnv *env, jobject thiz, jbyteArray ba) { char * data = (*env)->GetByteArrayElements(env, ba, 0); // int len = (*env)->GetArrayLength(env, ba); unsigned long deDataLen; char* deData = (char*)malloc(BUFFER_LEN); deDataLen = Base64decode(deData,data); jbyteArray jarrRV =(*env)->NewByteArray(env,deDataLen); (*env)->SetByteArrayRegion(env,jarrRV, 0,deDataLen, deData); (*env)->ReleaseByteArrayElements(env,ba,data,0); free(deData); return jarrRV; }
fzBuffer Data::B64Decode(const char *input, fzUInt inLength) { FZ_ASSERT(input, "Input pointer cannot be NULL"); FZ_ASSERT(inLength > 0, "Input data length cannot be 0."); //should be enough to store 6-bit buffers in 8-bit buffers fzUInt outputSize = Base64decode_len(input); char *output = new(std::nothrow) char[outputSize]; if( output ) { Base64decode(output, input); return fzBuffer(output, outputSize); }else{ FZLOGERROR("Base64: error allocating memory."); return fzBuffer::empty(); } }
inline Bool16 OSXAuthenticate(StrPtrLen *keyStrPtr) { #if __MacOSX__ // Authorization: AuthRef QWxhZGRpbjpvcGVuIHNlc2FtZQ== Bool16 result = false; if (keyStrPtr == NULL || keyStrPtr->Len == 0) return result; char *encodedKey = keyStrPtr->GetAsCString(); OSCharArrayDeleter encodedKeyDeleter(encodedKey); char *decodedKey = NEW char[Base64decode_len(encodedKey) + 1]; OSCharArrayDeleter decodedKeyDeleter(decodedKey); (void) Base64decode(decodedKey, encodedKey); AuthorizationExternalForm *receivedExtFormPtr = (AuthorizationExternalForm *) decodedKey; AuthorizationRef receivedAuthorization; OSStatus status = AuthorizationCreateFromExternalForm(receivedExtFormPtr, &receivedAuthorization); if (status != errAuthorizationSuccess) return result; status = AuthorizationCopyRights(receivedAuthorization, &sRightSet, kAuthorizationEmptyEnvironment, kAuthorizationFlagExtendRights , NULL); if (status == errAuthorizationSuccess) { result = true; } AuthorizationFree(receivedAuthorization, kAuthorizationFlagDestroyRights); return result; #else return false; #endif }
QTSS_Error RTSPRequest::ParseBasicHeader(StringParser *inParsedAuthLinePtr) { QTSS_Error theErr = QTSS_NoErr; fAuthScheme = qtssAuthBasic; StrPtrLen authWord; inParsedAuthLinePtr->ConsumeWhitespace(); inParsedAuthLinePtr->ConsumeUntilWhitespace(&authWord); if (0 == authWord.Len ) return theErr; char* encodedStr = authWord.GetAsCString(); OSCharArrayDeleter encodedStrDeleter(encodedStr); char *decodedAuthWord = NEW char[Base64decode_len(encodedStr) + 1]; OSCharArrayDeleter decodedAuthWordDeleter(decodedAuthWord); (void) Base64decode(decodedAuthWord, encodedStr); StrPtrLen nameAndPassword; nameAndPassword.Set(decodedAuthWord, ::strlen(decodedAuthWord)); StrPtrLen name(""); StrPtrLen password(""); StringParser parsedNameAndPassword(&nameAndPassword); parsedNameAndPassword.ConsumeUntil(&name,':'); parsedNameAndPassword.ConsumeLength(NULL, 1); parsedNameAndPassword.GetThruEOL(&password); // Set the qtssRTSPReqUserName and qtssRTSPReqUserPassword attributes in the Request object (void) this->SetValue(qtssRTSPReqUserName, 0, name.Ptr , name.Len, QTSSDictionary::kDontObeyReadOnly); (void) this->SetValue(qtssRTSPReqUserPassword, 0, password.Ptr , password.Len, QTSSDictionary::kDontObeyReadOnly); // Also set the qtssUserName attribute in the qtssRTSPReqUserProfile object attribute of the Request Object (void) fUserProfile.SetValue(qtssUserName, 0, name.Ptr, name.Len, QTSSDictionary::kDontObeyReadOnly); return theErr; }
/* * Signature: ([B)[B */ static jbyteArray Decrypto(JNIEnv *env, jobject thiz, jbyteArray ba, jint tp) { // monstartup("libjcryptoc.so"); // LOGPOS(); char * data = (*env)->GetByteArrayElements(env, ba, 0); // int len = (*env)->GetArrayLength(env, ba); unsigned long deDataLen; char* deData = (char*)malloc(CIPHER_BUFFER_LEN); deDataLen = Base64decode(deData,data); char * key; if(tp == 1){ key = PASS; }else if(tp == 2){ key = UPASS; }else{ key = NPASS; } int plainBufferLen; void * plainBuffer = malloc(BUFFER_LEN); plainBufferLen = MGDecryptor(deData, deDataLen, key, strlen(key), plainBuffer); free(deData); jbyteArray jarrRV =(*env)->NewByteArray(env,plainBufferLen); (*env)->SetByteArrayRegion(env,jarrRV, 0,plainBufferLen, plainBuffer); free(plainBuffer); (*env)->ReleaseByteArrayElements(env,ba,data,0); // setenv("CPUPROFILE", "/sdcard/gmon.out", 1); // moncleanup(); return jarrRV; }
extern "C" int Base64Decode(void* byteDataDest, const char* base64Src) { return Base64decode((char*) byteDataDest, base64Src); }
void nc_otoc_start(nc_opts *opts, int pair_raw_sock) { int shell_fd_sock; int pair_fd_sock; fd_set readfds; int maxfds; char time_str[NOW_STR_LEN]; enum {init, none, text_sent, text_received, pkey_sent, pkey_received} last_action = init; shell_fd_sock = fileno(stdin); pair_fd_sock = nc_utils_get_rec_sockfd(pair_raw_sock); maxfds = pair_fd_sock + 1; /* --- start of sending public key --- */ if(opts->secure) { char *msg = NULL; char *msg_type = OTOC_MTYPE_PKEY; char *msg_body = NULL; /* --- start of encoding public key --- */ const char *plain_pkey = (const char*) my_publickey; int plain_pkey_len = crypto_box_PUBLICKEYBYTES; char encoded_pkey[Base64encode_len(plain_pkey_len)]; Base64encode(encoded_pkey, plain_pkey, plain_pkey_len); nc_log_writef("debug", "encode my public key: %s", encoded_pkey); /* --- end of encoding public key --- */ msg_body = encoded_pkey; nc_json_make_otoc_msg(&msg_type, &msg_body, plain_pkey_len, &msg); nn_send(pair_raw_sock, msg, strlen(msg), 0); nc_log_writef("debug", "one to one chat sent public key: %s", msg); last_action = pkey_sent; } /* --- end of sending public key --- */ /* --- start of shel command registration --- */ nc_otoc_register_cmd("/help", func_cmd_help); nc_otoc_register_cmd("/leave", func_cmd_leave); /* --- end of shell commmand registration --- */ for(;;) { switch(last_action) { case init: case pkey_sent: fprintf(stdout, ">> Entering (room code %d) ...\n", pair_raw_sock); fprintf(stdout, ">>> "); fflush(stdout); break; case text_received: fprintf(stdout, ">>> "); fflush(stdout); break; case text_sent: fprintf(stdout, ">>> "); fflush(stdout); break; case none: fprintf(stdout, ">>> "); fflush(stdout); break; case pkey_received: break; } FD_ZERO(&readfds); FD_SET(pair_fd_sock, &readfds); FD_SET(shell_fd_sock, &readfds); select(maxfds, &readfds, NULL, NULL, NULL); if(FD_ISSET(shell_fd_sock, &readfds)) { char *buf = NULL; size_t buf_sz = 1024; int i; nc_utils_now_str(time_str); getline(&buf, &buf_sz, stdin); if(buf[0] == '\n') { last_action = none; } else if(buf[0] == '/') { nc_utils_del_new_line(buf); for(i = 0; i < cmd_current_code; i++) { if(strstr(buf, cmds[i].name)) { if(cmds[i].func(buf) < 0) { return; } break; } } last_action = none; } else { if(opts->secure) { /* --- make ciphermsg with key pairs --- */ int ciphermsg_len = crypto_box_MACBYTES + strlen(buf); unsigned char nonce[crypto_box_NONCEBYTES]; unsigned char ciphermsg[ciphermsg_len]; /* @TODO: use random nonce */ //randombytes_buf(nonce, sizeof nonce); memset(nonce, '\0', sizeof nonce); crypto_box_easy(ciphermsg, (const unsigned char*) buf, strlen(buf), nonce, peers_publickey[pair_raw_sock], my_secretkey); /* --- make msg encoded with base64 --- */ const char *plain_ciphermsg = (const char*) ciphermsg; int plain_ciphermsg_len = ciphermsg_len; int encoded_ciphermsg_len = Base64encode_len(plain_ciphermsg_len); char encoded_ciphermsg[encoded_ciphermsg_len]; Base64encode(encoded_ciphermsg, plain_ciphermsg, plain_ciphermsg_len); nc_log_writef("debug", "encode ciphermsg: %s", encoded_ciphermsg); /* --- serialize msg with json --- */ char *msg = NULL; char *msg_type = OTOC_MTYPE_STXT; char *msg_body = NULL; msg_body = encoded_ciphermsg; nc_json_make_otoc_msg(&msg_type, &msg_body, strlen(buf), &msg); nc_log_writef("debug", "serialize encoded ciphermsg: %s", msg); /* --- send msg --- */ nn_send(pair_raw_sock, msg, strlen(msg), 0); } else { char *msg = NULL; char *msg_type = OTOC_MTYPE_RTXT; nc_json_make_otoc_msg(&msg_type, &buf, strlen(buf), &msg); nn_send(pair_raw_sock, msg, strlen(msg), 0); fprintf(stdout, "[%s] >>> %s", time_str, buf); fflush(stdout); nc_utils_del_new_line(buf); nc_log_writef("debug", "one to one chat sent: %s", buf); nc_utils_empty_string(buf); last_action = text_sent; } } } else if(FD_ISSET(pair_fd_sock, &readfds)) { char *buf = NULL; char *msg_body = NULL; char *msg_type = NULL; int original_msg_body_len; nn_recv(pair_raw_sock, &buf, NN_MSG, 0); nc_json_extract_otoc_msg(&buf, &msg_type, &original_msg_body_len, &msg_body); nc_utils_del_new_line(buf); nc_log_writef("debug", "one to one chat received: %s", msg_type); nn_freemsg(buf); if(strncmp(msg_type, OTOC_MTYPE_PKEY, OTOC_MTYPE_LEN) == 0) { /* public key message */ /* --- start of decoding public key --- */ int plain_pkey_len = Base64decode_len(msg_body); char plain_pkey[plain_pkey_len]; Base64decode(plain_pkey, (const char*) msg_body); strncpy(peers_publickey[pair_raw_sock], plain_pkey, crypto_box_PUBLICKEYBYTES); nc_log_writef("debug", "decoded peer's public key was stored."); /* --- end of decoding public key --- */ last_action = pkey_received; } else if(strncmp(msg_type, OTOC_MTYPE_RTXT, OTOC_MTYPE_LEN) == 0) { /* raw text message */ nc_utils_now_str(time_str); fprintf(stdout, "\r[%s] <<< %s", time_str, msg_body); fflush(stdout); last_action = text_received; } else if(strncmp(msg_type, OTOC_MTYPE_STXT, OTOC_MTYPE_LEN) == 0) { /* secure text message */ if(!opts->secure) { char *alert = "\r[%s] <<< { ... encrypted message ... }\n" "==========================================\n" "Your peer uses NanoChat undre secure mode.\n" "Use -s flag to see his encrypted messages.\n" "==========================================\n"; nc_utils_now_str(time_str); fprintf(stdout, alert, time_str); fflush(stdout); last_action = text_received; } else { /* --- decode secure msg body --- */ int plain_ciphermsg_len = Base64decode_len(msg_body); char plain_ciphermsg[plain_ciphermsg_len]; Base64decode(plain_ciphermsg, (const char*) msg_body); /* --- decrypt ciphermsg --- */ int decrypted_len = original_msg_body_len; int ciphermsg_len = crypto_box_MACBYTES + decrypted_len; unsigned char decrypted[decrypted_len]; unsigned char nonce[crypto_box_NONCEBYTES]; memset(nonce, '\0', sizeof nonce); crypto_box_open_easy(decrypted, plain_ciphermsg, ciphermsg_len, nonce, peers_publickey[pair_raw_sock], my_secretkey); /* --- show decrypted msg body --- */ decrypted[original_msg_body_len] = '\0'; nc_utils_now_str(time_str); fprintf(stdout, "\r[%s] <<< %s", time_str, decrypted); fflush(stdout); last_action = text_received; } } } } }
static bool CreateDictionaryFromXMLRecursive(char *data, int size, CFMutableDictionaryRef *dict, char *key) { if (size == 0) return true; xml_token tok; char *buf = data; int bytesleft = size, closeindex; bool bClosed, bAllocatedKey = false; while (bytesleft) { // skip whitespace if (isspace(buf[0])) { buf++; bytesleft--; continue; } bClosed = false; closeindex = -1; // get XML token if (!GetNextToken(&buf, &bytesleft, &tok, &bClosed)) { if (bAllocatedKey) free(key); return false; } // closed XML token? if (bClosed) { if (key == NULL) continue; if (*dict == NULL) { if (bAllocatedKey) free(key); return false; } CFBooleanRef value = NULL; if (!strcasecmp(tok.id, "true")) { value = kCFBooleanTrue; } else if (!strcasecmp(tok.id, "false")) { value = kCFBooleanFalse; } if (value != NULL) { CFStringRef cfkey = CFStringCreateWithCString(kCFAllocatorDefault, key, kCFStringEncodingUTF8); if (bAllocatedKey) { free(key); key = NULL; bAllocatedKey = false; } if (cfkey == NULL) { return false; } CFDictionaryAddValue(*dict, cfkey, value); } else if (bAllocatedKey) { free(key); key = NULL; bAllocatedKey = false; } continue; } // check for token types we know about if (!strcasecmp(tok.id, "key")) { if (bAllocatedKey) free(key); if (*dict == NULL) return false; closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "key"); if (closeindex == -1) return false; key = (char*)malloc(closeindex+1); strncpy(key, buf, closeindex); key[closeindex] = 0; StripWhitespace(&key); #ifdef DEBUG printf("key = %s\n", key); #endif // empty keys are not allowed if (strlen(key) == 0) { free(key); return false; } bAllocatedKey = true; buf += closeindex + 6; bytesleft -= closeindex + 6; } else if (!strcasecmp(tok.id, "dict")) { if (key == NULL) { if (*dict != NULL) return false; closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "dict"); if (closeindex == -1) { return false; } *dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (*dict == NULL) { return false; } if (!CreateDictionaryFromXMLRecursive(buf, closeindex, dict, NULL)) { CFRelease(*dict); return false; } return true; } else if (*dict != NULL) { closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "dict"); if (closeindex == -1) { if (bAllocatedKey) free(key); return false; } CFMutableDictionaryRef dict2 = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (dict2 == NULL) { if (bAllocatedKey) free(key); return false; } if (!CreateDictionaryFromXMLRecursive(buf, closeindex, &dict2, NULL)) { if (bAllocatedKey) free(key); CFRelease(dict2); return false; } CFStringRef cfkey = CFStringCreateWithCString(kCFAllocatorDefault, key, kCFStringEncodingUTF8); if (bAllocatedKey) { free(key); key = NULL; bAllocatedKey = false; } if (cfkey == NULL) { CFRelease(dict2); return false; } CFDictionaryAddValue(*dict, cfkey, dict2); buf += closeindex + 7; bytesleft -= closeindex + 7; } else { if (bAllocatedKey) free(key); return false; } } else if (!strcasecmp(tok.id, "data")) { if ( (key == NULL) || (*dict == NULL) ) return false; closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "data"); if (closeindex == -1) { if (bAllocatedKey) free(key); return false; } CFStringRef cfkey = CFStringCreateWithCString(kCFAllocatorDefault, key, kCFStringEncodingUTF8); if (bAllocatedKey) { free(key); key = NULL; bAllocatedKey = false; } if (cfkey == NULL) { return false; } char *value = (char*)malloc(closeindex+1); strncpy(value, buf, closeindex); value[closeindex] = 0; StripWhitespace(&value); if (strlen(value) > 0) { // Base64 decode the data int decodelen = Base64decode_len(value); if (decodelen > 0) { char *decodedval = (char*)malloc(decodelen); Base64decode(decodedval, value); free(value); value = decodedval; } } CFDataRef cfvalue = CFDataCreate(kCFAllocatorDefault, (const UInt8*)value, strlen(value)); free(value); if (cfvalue == NULL) { return false; } CFDictionaryAddValue(*dict, cfkey, cfvalue); buf += closeindex + 7; bytesleft -= closeindex + 7; } else if (!strcasecmp(tok.id, "string")) { if ( (key == NULL) || (*dict == NULL) ) return false; closeindex = PIGetIndexOfClosingTag(buf, bytesleft, "string"); if (closeindex == -1) { if (bAllocatedKey) free(key); return false; } CFStringRef cfkey = CFStringCreateWithCString(kCFAllocatorDefault, key, kCFStringEncodingUTF8); if (bAllocatedKey) { free(key); key = NULL; bAllocatedKey = false; } if (cfkey == NULL) { return false; } char *value = (char*)malloc(closeindex+1); strncpy(value, buf, closeindex); value[closeindex] = 0; StripWhitespace(&value); #ifdef DEBUG printf("string = %s\n", value); #endif CFStringRef cfvalue = CFStringCreateWithCString(kCFAllocatorDefault, value, kCFStringEncodingUTF8); free(value); if (cfvalue == NULL) { return false; } CFDictionaryAddValue(*dict, cfkey, cfvalue); buf += closeindex + 9; bytesleft -= closeindex + 9; } else if (!strcasecmp(tok.id, "?xml") || !strcasecmp(tok.id, "!DOCTYPE") || !strcasecmp(tok.id, "plist")) { // Ignore } else { // unknown token -- just skip it if (bAllocatedKey) { free(key); key = NULL; bAllocatedKey = false; } closeindex = PIGetIndexOfClosingTag(buf, bytesleft, tok.id); if (closeindex == -1) { return false; } buf += closeindex + strlen(tok.id) + 3; bytesleft -= closeindex + strlen(tok.id) + 3; } } if (bAllocatedKey) free(key); return true; }
void* SomeAwesomeThings(void* Param){ Client* theClient = (Client*)Param; char* message = (char*)malloc(4086); char sendMessage[4086]; char encrypt[4086]; char* receiver; char* tmp; char* ender; char* err; Client* ClientCounter; int msgSize; int usernameSet = 0; int nameLength; int sub_msg_len; int encrypt_len; //RC4 component RC4Container RC4key; int iter1; int iter2; RC4key.iter1 = &iter1; RC4key.iter2 = &iter2; int RC4KeySet = 0; // unsigned char hash_out[SHA_DIGEST_LENGTH + 1]; char hash_string[SHA_DIGEST_LENGTH * 2 + 1]; int iterator; memset(sendMessage, '\0', sizeof(sendMessage)); err = (char*) malloc(130); // if((msgSize = read(theClient->sockfd, message, sizeof(message) - 1)) > 0){ // message[msgSize] = '\0'; // int nameLength = strstr(message, "\r\n.\r\n") - message; // for(msgSize = 0; msgSize < nameLength; msgSize++){ // theClient->Name[msgSize] = message[msgSize]; // } // theClient->Name[nameLength] = '\0'; // printf("%s has connected\n", theClient->Name); // } while((msgSize = read(theClient->sockfd, message, 4086 - 1)) > 0){ message[msgSize] = '\0'; sub_msg_len = 0; while((ender = strstr(message, "\r\n.\r\n")) != NULL){ // *ender = '\0'; sub_msg_len += ender - message + 5; if(sub_msg_len > msgSize) break; // printf("%s\n", message); //Do things here tmp = strstr(message, "\r\n"); *tmp = '\0'; printf("%s\n", message); if(strcmp(message, "Mode: Public") == 0){ tmp = tmp + 2; nameLength = strstr(tmp, "\r\n.\r\n") - tmp + 5; sprintf(sendMessage,"%s\r\nUser: %s\r\n", message, theClient->Name); strncat(sendMessage, tmp, nameLength); for(ClientCounter = head; ClientCounter != NULL; ClientCounter = ClientCounter->Next){ if(ClientCounter == theClient) continue; write(ClientCounter->sockfd, sendMessage, sizeof(sendMessage)); } } else if((strcmp(message, "Mode: Private") == 0) || (strcmp(message, "Mode: InitPriv") == 0) || (strcmp(message, "Mode: AccPriv") == 0) ){ tmp = tmp + 2; tmp = strstr(tmp, " ") + 1; receiver = tmp; tmp = strstr(tmp, "\r\n"); *tmp = '\0'; tmp = tmp + 2; nameLength = strstr(tmp, "\r\n.\r\n") - tmp + 5; sprintf(sendMessage,"%s\r\nUser: %s\r\n", message, theClient->Name); strncat(sendMessage, tmp, nameLength); for(ClientCounter = head; ClientCounter != NULL; ClientCounter = ClientCounter->Next){ if(strcmp(receiver, ClientCounter->Name) == 0){ write(ClientCounter->sockfd, sendMessage, sizeof(sendMessage)); break; } } } else if(strcmp(message, "Mode: GetList") == 0){ sprintf(sendMessage, "Mode: List\r\n"); for(ClientCounter = head; ClientCounter != NULL; ClientCounter = ClientCounter->Next){ if(ClientCounter == theClient)continue; strcat(sendMessage, ClientCounter->Name); strcat(sendMessage, "\r\n"); } strcat(sendMessage, "\r\n.\r\n"); write(theClient->sockfd, sendMessage, sizeof(sendMessage)); } else if(strcmp(message, "Mode: Username") == 0){ tmp = tmp + 2; if(usernameSet == 0){ if(RC4KeySet == 1){ printf("Setting username\n"); nameLength = strstr(tmp, "\r\n.\r\n") - tmp; char* decode; int decode_len = Base64decode(tmp, (unsigned char**)&decode, nameLength); encrypt_len = RC4Crypt(decode_len, (unsigned char*)decode, (unsigned char*)encrypt, &RC4key); free(decode); tmp = strstr(encrypt, "\r\n.,\r\n"); nameLength = tmp - encrypt; *tmp = '\0'; tmp = tmp + 6; if(CheckHashValidation(nameLength, (unsigned char*)encrypt, tmp) == 1){ for(msgSize = 0; msgSize < nameLength; msgSize++){ theClient->Name[msgSize] = *(encrypt + msgSize); } theClient->Name[nameLength] = '\0'; printf("%s\n", theClient->Name); usernameSet++; } } } } else if(strcmp(message, "Mode: GetCA") == 0){ sprintf(sendMessage, "Mode: ServCA\r\n"); strcat(sendMessage, public_key); strcat(sendMessage, "\r\n.\r\n"); write(theClient->sockfd, sendMessage, sizeof(sendMessage)); } else if(strcmp(message, "Mode: SetPubKey") == 0){ tmp = tmp + 2; nameLength = strstr(tmp, "\r\n.\r\n") - tmp; if(RC4KeySet == 1){ char* decoded; int decoded_len = Base64decode(tmp, (unsigned char**)&decoded, nameLength); encrypt_len = RC4Crypt(decoded_len, (unsigned char*)decoded, (unsigned char*)encrypt, &RC4key); free(decoded); encrypt[encrypt_len] = '\0'; tmp = strstr(encrypt, "\r\n.,\r\n"); nameLength = tmp - encrypt; *tmp = '\0'; tmp = tmp + 6; if(CheckHashValidation(nameLength, (unsigned char*)encrypt, tmp) == 1){ for(iterator = 0; iterator < nameLength; iterator++){ *(theClient->public_key + iterator) = *(encrypt + iterator); } *(theClient->public_key + nameLength) = '\0'; } else{ //TODO: Return some error printf("Failed to set public key\n"); sprintf(sendMessage, "Mode: FailPubKey\r\n.\r\n"); write(theClient->sockfd, sendMessage, sizeof(sendMessage)); } } } else if(strcmp(message, "Mode: SetRC4Key") == 0){ if(RC4KeySet == 0){ tmp = tmp + 2; nameLength = strstr(tmp, "\r\n.\r\n") - tmp; char* decoded; int dedoded_len = Base64decode(tmp, (unsigned char**)&decoded, nameLength); if((encrypt_len = private_decrypt((unsigned char*)decoded, dedoded_len, (unsigned char*)private_key, (unsigned char*)encrypt, RSA_PKCS1_OAEP_PADDING)) == -1){ ERR_load_crypto_strings(); ERR_error_string(ERR_get_error(), err); fprintf(stderr, "Error decrypting message: %s\n", err); sprintf(sendMessage, "Mode: FailRC4Key\r\n.\r\n"); write(theClient->sockfd, sendMessage, sizeof(sendMessage)); } else{ tmp = strstr(encrypt, "\r\n.,\r\n"); nameLength = tmp - encrypt; *tmp = '\0'; tmp = tmp + 6; //TODO: Check if hash of encrypt is the same with tmp if(CheckHashValidation(nameLength, (unsigned char*)encrypt, tmp) == 1){ initRC4key(&RC4key, encrypt, nameLength); RC4KeySet = 1; } else{ sprintf(sendMessage, "Mode: FailRC4Key\r\n.\r\n"); write(theClient->sockfd, sendMessage, sizeof(sendMessage)); } } free(decoded); } } else if(strcmp(message, "Mode: GetPubKey") == 0){ tmp = tmp + 2; tmp = strstr(tmp, " ") + 1; receiver = tmp; tmp = strstr(tmp, "\r\n"); *tmp = '\0'; for(ClientCounter = head; ClientCounter != NULL; ClientCounter = ClientCounter->Next){ if(strcmp(receiver, ClientCounter->Name) == 0) break; } if(ClientCounter != NULL){ if(ClientCounter->public_key[0] != '\0' && RC4KeySet == 1){ SHA1((unsigned char*)ClientCounter->public_key, strlen(ClientCounter->public_key), (unsigned char*)hash_out); for(iterator = 0; iterator < SHA_DIGEST_LENGTH; iterator++){ sprintf(&hash_string[iterator * 2], "%02x", (unsigned int)hash_out[iterator]); } sprintf(sendMessage, "%s\r\n.,\r\n%s", ClientCounter->public_key, hash_string); encrypt_len = RC4Crypt(strlen(sendMessage), (unsigned char*)sendMessage, (unsigned char*)encrypt, &RC4key); encrypt[encrypt_len] = '\0'; char* encoded; int encoded_len = Base64encode(encrypt, encrypt_len, &encoded); encoded[encoded_len] = '\0'; sprintf(sendMessage, "Mode: ClientPubKey\r\nUser: %s\r\n%s\r\n.\r\n", ClientCounter->Name, encoded); free(encoded); printf("%s\n", sendMessage); printf("%s\n", ClientCounter->public_key); write(theClient->sockfd, sendMessage, sizeof(sendMessage)); } else{ sprintf(sendMessage, "Mode: FailPubKey\r\nUser: %s\r\n.\r\n", ClientCounter->Name); } } } *ender = '\0'; ender += 5; message = ender; } } printf("%s has been disconnected\n", theClient->Name); if(theClient == head){ head = theClient->Next; if(head != NULL)head->Previous = NULL; else tail = NULL; } else{ theClient->Previous->Next = theClient->Next; if(theClient == tail){ tail = theClient->Previous; } } if(theClient->keypair != NULL) RSA_free(theClient->keypair); free(theClient); return NULL; }
/** * Calculate the real key from master key, encrypted data key */ static int key_calculate_real(fcgienc_crypt * fc) { int i; ssize_t len; unsigned char mkhex[32], ivhex[16]; char decodebuf[KEY_SIZE]; int decodelen; unsigned char keystr[KEY_SIZE]; char *keyencbase64; if (!fc) return -1; keyencbase64 = fc->encryptedDataKey; // string -> hex of master key memset(mkhex, 0, 32); len = strlen(fc->masterKey)&0xFFFFFFFE; for (i=0; i<len; i+=2) { char c[3]; if (i>=64) break; c[0] = fc->masterKey[i]; c[1] = fc->masterKey[i+1]; c[2] = 0; sscanf(c, "%x", (unsigned int *)&mkhex[i/2]); } if ((i<64) && (len < strlen(fc->masterKey))) { char c[3]; c[0] = fc->masterKey[len]; c[1] = '0'; c[2] = 0; sscanf(c, "%x", (unsigned int *)&mkhex[i/2]); } // string -> hex of data key memset(ivhex, 0, 16); len = strlen(fc->initializationVector)&0xFFFFFFFE; for (i=0; i<len; i+=2) { char c[3]; if (i>=32) break; c[0] = fc->initializationVector[i]; c[1] = fc->initializationVector[i+1]; c[2] = 0; sscanf(c, "%x", (unsigned int *)&ivhex[i/2]); } if ((i<32) && (len < strlen(fc->initializationVector))) { char c[3]; c[0] = fc->initializationVector[len]; c[1] = '0'; c[2] = 0; sscanf(c, "%x", (unsigned int *)&ivhex[i/2]); } // decode base64 decodelen = Base64decode(decodebuf, keyencbase64); // decrypt key memset(keystr, 0, KEY_SIZE); len = DecryptAesCBC((unsigned char *)decodebuf, decodelen, keystr, mkhex, ivhex); if (len < 0) { log_keythread("KEY-THREAD - AES-CBC decryption failed with key %s", fc->dataKeyId); return -1; } // store into variable memcpy(fc->dataKey, keystr, len); fc->dataKey[len] = 0; fc->dataKeyLength = len; return 0; }