TEST(Base64Tests, FromBase64) { EXPECT_EQ("", from_base64("")); EXPECT_EQ("a", from_base64("YQ==")); EXPECT_EQ("ab", from_base64("YWI=")); EXPECT_EQ("abc", from_base64("YWJj")); EXPECT_EQ("abcd", from_base64("YWJjZA==")); }
int unpack_attributes_record(JCR *jcr, int32_t stream, char *rec, ATTR *attr) { char *p; /* * An Attributes record consists of: * File_index * Type (FT_types) * Filename * Attributes * Link name (if file linked i.e. FT_LNK) * Extended attributes (Win32) * plus optional values determined by AR_ flags in upper bits of Type * Data_stream * */ attr->stream = stream; Dmsg1(400, "Attr: %s\n", rec); if (sscanf(rec, "%d %d", &attr->file_index, &attr->type) != 2) { Jmsg(jcr, M_FATAL, 0, _("Error scanning attributes: %s\n"), rec); Dmsg1(100, "\nError scanning attributes. %s\n", rec); return 0; } Dmsg2(400, "Got Attr: FilInx=%d type=%d\n", attr->file_index, attr->type); if (attr->type & AR_DATA_STREAM) { attr->data_stream = 1; } else { attr->data_stream = 0; } attr->type &= FT_MASK; /* keep only type bits */ p = rec; while (*p++ != ' ') /* skip record file index */ { } while (*p++ != ' ') /* skip type */ { } attr->fname = p; /* set filname position */ while (*p++ != 0) /* skip filename */ { } attr->attr = p; /* set attributes position */ while (*p++ != 0) /* skip attributes */ { } attr->lname = p; /* set link position */ while (*p++ != 0) /* skip link */ { } pm_strcpy(attr->attrEx, p); /* copy extended attributes, if any */ if (attr->data_stream) { int64_t val; while (*p++ != 0) /* skip extended attributes */ { } from_base64(&val, p); attr->data_stream = (int32_t)val; } Dmsg7(400, "unpack_attr FI=%d Type=%d fname=%s attr=%s lname=%s attrEx=%s ds=%d\n", attr->file_index, attr->type, attr->fname, attr->attr, attr->lname, attr->attrEx, attr->data_stream); *attr->ofname = 0; *attr->olname = 0; return 1; }
static uint64_t decode_req(const char *buf) { int64_t val; const char *p=buf; p+=from_base64(&val, p); return (uint64_t)val; }
int sc_base64_decode(const char *in, u8 *out, size_t outlen) { int len = 0, r, skip; unsigned int i; while ((r = from_base64(in, &i, &skip)) > 0) { int finished = 0, s = 16; if (r < 3) finished = 1; while (r--) { if (outlen <= 0) return SC_ERROR_BUFFER_TOO_SMALL; *out++ = i >> s; s -= 8; outlen--; len++; } in += skip; if (finished || *in == 0) return len; } if (r == 0) return len; return SC_ERROR_INVALID_ARGUMENTS; }
/** Decode a LinkFI field of encoded stat packet */ int32_t decode_LinkFI(char *buf, struct stat *statp, int stat_size) { char *p = buf; int64_t val; /* * We store into the stat packet so make sure the caller's conception * is the same as ours. They can be different if LARGEFILE is not * the same when compiling this library and the calling program. */ ASSERT(stat_size == (int)sizeof(struct stat)); skip_nonspaces(&p); /* st_dev */ p++; /* skip space */ skip_nonspaces(&p); /* st_ino */ p++; p += from_base64(&val, p); plug(statp->st_mode, val); /* st_mode */ p++; skip_nonspaces(&p); /* st_nlink */ p++; skip_nonspaces(&p); /* st_uid */ p++; skip_nonspaces(&p); /* st_gid */ p++; skip_nonspaces(&p); /* st_rdev */ p++; skip_nonspaces(&p); /* st_size */ p++; skip_nonspaces(&p); /* st_blksize */ p++; skip_nonspaces(&p); /* st_blocks */ p++; skip_nonspaces(&p); /* st_atime */ p++; skip_nonspaces(&p); /* st_mtime */ p++; skip_nonspaces(&p); /* st_ctime */ /* Optional FileIndex of hard linked file data */ if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; p += from_base64(&val, p); return (int32_t)val; } return 0; }
uint64_t decode_file_no_and_save_path(struct iobuf *iobuf, char **save_path) { int64_t val; char *p=iobuf->buf; p+=from_base64(&val, iobuf->buf); *save_path=p+1; return (uint64_t)val; }
int main(int argc, char **argv) { pool p[1] = { pool_create() }; random_init(); /* biases at 16 and 32, so we prefix our 30 byte secret with * two bytes to start with, up to 17 */ byteblock prefix = { (uint8_t *) "AAAAAAAAAAAAAAAAAA", 2 }; assert(argc == 2); byteblock secret = from_base64(p, argv[1]); assert(secret.len == SECRET_LEN); unsigned counts[SECRET_LEN][256]; memset(counts, 0, sizeof(counts)); while (prefix.len < 18) { uint8_t buf[64]; byteblock bb = { buf, 0 }; for (size_t i = 0; i < ROUNDS; i++) { oracle(&prefix, &secret, &bb); if (prefix.len <= 15) { /* bias at 16 towards 240 (full) 0 (half) 16 (half) */ uint8_t b16 = buf[15]; counts[15 - prefix.len][b16 ^ 240] += FULL_WEIGHT; counts[15 - prefix.len][b16 ^ 0] += HALF_WEIGHT; counts[15 - prefix.len][b16 ^ 16] += HALF_WEIGHT; } /* bias at 32 towards 224 (full) 0 (half) 32 (half) */ uint8_t b32 = buf[31]; counts[31 - prefix.len][b32 ^ 224] += FULL_WEIGHT; counts[31 - prefix.len][b32 ^ 0] += HALF_WEIGHT; counts[31 - prefix.len][b32 ^ 32] += HALF_WEIGHT; } prefix.len++; byteblock plaintext = recover(p, counts); printf("guess: %s\n", to_ascii(p, &plaintext)); } byteblock recovered = recover(p, counts); printf("message: %s\n", to_ascii(p, &recovered)); p->finish(p); return 0; }
int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata) { char *intext, *decoded_intext; if(!xmpp_stanza_get_child_by_name(stanza, "body")) return 1; if(!strcmp(xmpp_stanza_get_attribute(stanza, "type"), "error")) return 1; intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "body")); decoded_intext = from_base64(intext, strlen(intext)); fwrite((const void*)decoded_intext, 1, strlen(intext), stdout); free(decoded_intext); return 1; }
int main(int argc, char *argv[]) { /* You can modify this file as needed, for example to test different * files. If you run on command line, this function optionally reads * the filename from command line, if one is given. */ char *filename = "testi.txt"; if (argc > 1) { filename = argv[1]; } // Write encoded file to 'testi.enc' int n = to_base64("testi.enc", filename); printf("to_base64 returned: %d\n", n); // Follow with reverse operation -- 'testi.ver' should be same as // your original source file n = from_base64("testi.ver", "testi.enc"); printf("from_base64 returned: %d\n", n); }
static void db_replay_log_table_set_keys_iter(heim_object_t key, heim_object_t value, void *arg) { heim_db_t db = arg; heim_data_t k, v; if (db->ret) return; k = from_base64((heim_string_t)key, &db->error); if (k == NULL) { db->ret = ENOMEM; return; } v = (heim_data_t)value; db->ret = db->plug->setf(db->db_data, db->current_table, k, v, &db->error); heim_release(k); }
int main(int argc, char **argv) { pool p[1] = { pool_create() }; assert(argc == 2); byteblock cipher = from_base64(p, argv[1]); int best_score = INT_MAX; byteblock best_key; byteblock best_plaintext; // this is actually quick enough and easier to bruteforce: 40 * 256 * 256 tries for (size_t k = 2; k < MAX_KEYLEN; k++) { byteblock key = { p->alloc(p, k), k }; for (size_t i = 0; i < key.len; i++) { key.buf[i] = find_key_byte(p, &cipher, i, key.len); } byteblock plain = byteblock_xor(p, &cipher, &key); int score = score_english(&plain); if (score < best_score) { best_score = score; best_key = key; best_plaintext = plain; } } printf("key: %s, plain: %s\n", to_hex(p, &best_key), to_ascii(p, &best_plaintext)); p->finish(p); return 0; }
// Decode a stat packet from base64 characters. void attribs_decode(struct sbuf *sb) { static const char *p; static int64_t val; static struct stat *statp; if(!(p=sb->attr.buf)) return; statp=&sb->statp; if(sb->burp2) { // Burp1 does not have this field. p += from_base64(&val, p); sb->burp2->index=val; p++; // Compression for burp2. p += from_base64(&val, p); sb->compression=val; p++; // Burp1 does not have this field. p += from_base64(&val, p); sb->burp2->encryption=val; p++; } p += from_base64(&val, p); plug(statp->st_dev, val); p++; p += from_base64(&val, p); plug(statp->st_ino, val); p++; p += from_base64(&val, p); plug(statp->st_mode, val); p++; p += from_base64(&val, p); plug(statp->st_nlink, val); p++; p += from_base64(&val, p); plug(statp->st_uid, val); p++; p += from_base64(&val, p); plug(statp->st_gid, val); p++; p += from_base64(&val, p); plug(statp->st_rdev, val); p++; p += from_base64(&val, p); plug(statp->st_size, val); p++; p += from_base64(&val, p); #ifdef HAVE_WIN32 // plug(statp->st_blksize, val); p++; p += from_base64(&val, p); // plug(statp->st_blocks, val); #else plug(statp->st_blksize, val); p++; p += from_base64(&val, p); plug(statp->st_blocks, val); #endif p++; p += from_base64(&val, p); plug(statp->st_atime, val); p++; p += from_base64(&val, p); plug(statp->st_mtime, val); p++; p += from_base64(&val, p); plug(statp->st_ctime, val); // FreeBSD user flags. if(*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; if(!*p) return; p += from_base64(&val, p); #ifdef HAVE_CHFLAGS plug(statp->st_flags, val); } else { statp->st_flags = 0; #endif } // Look for winattr. if(*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; p += from_base64(&val, p); } else val = 0; sb->winattr=val; // Compression for burp1. if(sb->burp1) { if(*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; if(!*p) return; p += from_base64(&val, p); sb->compression=val; } else sb->compression=-1; } }
/** * Set Extended File Attributes for Win32 * * fname is the original filename * ofile is the output filename (may be in a different directory) * * Returns: true on success * false on failure */ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) { char *p = attr->attrEx; int64_t val; WIN32_FILE_ATTRIBUTE_DATA atts; ULARGE_INTEGER li; /** if we have neither Win ansi nor wchar API, get out */ if (!(p_SetFileAttributesW || p_SetFileAttributesA)) { return false; } if (!p || !*p) { /* we should have attributes */ Dmsg2(100, "Attributes missing. of=%s ofd=%d\n", attr->ofname, ofd->fid); if (is_bopen(ofd)) { bclose(ofd); } return false; } else { Dmsg2(100, "Attribs %s = %s\n", attr->ofname, attr->attrEx); } p += from_base64(&val, p); plug(atts.dwFileAttributes, val); p++; /* skip space */ p += from_base64(&val, p); li.QuadPart = val; atts.ftCreationTime.dwLowDateTime = li.LowPart; atts.ftCreationTime.dwHighDateTime = li.HighPart; p++; /* skip space */ p += from_base64(&val, p); li.QuadPart = val; atts.ftLastAccessTime.dwLowDateTime = li.LowPart; atts.ftLastAccessTime.dwHighDateTime = li.HighPart; p++; /* skip space */ p += from_base64(&val, p); li.QuadPart = val; atts.ftLastWriteTime.dwLowDateTime = li.LowPart; atts.ftLastWriteTime.dwHighDateTime = li.HighPart; p++; p += from_base64(&val, p); plug(atts.nFileSizeHigh, val); p++; p += from_base64(&val, p); plug(atts.nFileSizeLow, val); /** At this point, we have reconstructed the WIN32_FILE_ATTRIBUTE_DATA pkt */ if (!is_bopen(ofd)) { Dmsg1(100, "File not open: %s\n", attr->ofname); bopen(ofd, attr->ofname, O_WRONLY | O_BINARY, 0, 0); /* attempt to open the file */ } /* * Restore file attributes and times on the restored file. */ if (!win32_restore_file_attributes(attr->ofname, bget_handle(ofd), &atts)) { win_error(jcr, "win32_restore_file_attributes:", attr->ofname); } if (is_bopen(ofd)) { bclose(ofd); } return true; }
int www_authenticate(int sd, rr_data_t request, rr_data_t response, struct auth_s *creds) { char *tmp, *buf, *challenge; rr_data_t auth; int len; int rc = 0; buf = new(BUFSIZE); strcpy(buf, "NTLM "); len = ntlm_request(&tmp, creds); if (len) { to_base64(MEM(buf, unsigned char, 5), MEM(tmp, unsigned char, 0), len, BUFSIZE-5); free(tmp); } auth = dup_rr_data(request); auth->headers = hlist_mod(auth->headers, "Connection", "keep-alive", 1); auth->headers = hlist_mod(auth->headers, "Authorization", buf, 1); auth->headers = hlist_mod(auth->headers, "Content-Length", "0", 1); auth->headers = hlist_del(auth->headers, "Transfer-Encoding"); /* * Drop whatever error page server returned */ if (!http_body_drop(sd, response)) goto bailout; if (debug) { printf("\nSending WWW auth request...\n"); hlist_dump(auth->headers); } if (!headers_send(sd, auth)) goto bailout; if (debug) printf("\nReading WWW auth response...\n"); /* * Get NTLM challenge */ reset_rr_data(auth); if (!headers_recv(sd, auth)) { goto bailout; } if (debug) hlist_dump(auth->headers); /* * Auth required? */ if (auth->code == 401) { if (!http_body_drop(sd, auth)) goto bailout; tmp = hlist_get(auth->headers, "WWW-Authenticate"); if (tmp && strlen(tmp) > 6 + 8) { challenge = new(strlen(tmp) + 5 + 1); len = from_base64(challenge, tmp + 5); if (len > NTLM_CHALLENGE_MIN) { len = ntlm_response(&tmp, challenge, len, creds); if (len > 0) { strcpy(buf, "NTLM "); to_base64(MEM(buf, unsigned char, 5), MEM(tmp, unsigned char, 0), len, BUFSIZE-5); request->headers = hlist_mod(request->headers, "Authorization", buf, 1); free(tmp); } else {
static int deal_with_read(struct iobuf *rbuf, struct slist *slist, struct blist *blist, struct conf *conf, int *backup_end, int *requests_end, int *blk_requests_end) { int ret=0; switch(rbuf->cmd) { /* Incoming file request. */ case CMD_FILE: if(add_to_file_requests(slist, rbuf, conf)) goto error; return 0; /* Incoming data block request. */ case CMD_DATA_REQ: if(add_to_data_requests(blist, rbuf)) goto error; goto end; /* Incoming control/message stuff. */ case CMD_WRAP_UP: { int64_t wrap_up; struct blk *blk; from_base64(&wrap_up, rbuf->buf); for(blk=blist->head; blk; blk=blk->next) { if(blk->index==(uint64_t)wrap_up) { blist->last_requested=blk; blist->last_sent=blk; break; } } if(!blk) { #ifdef HAVE_WIN32 logp("Could not find wrap up index: %016I64X\n", #else logp("Could not find wrap up index: %016lX\n", #endif wrap_up); logp("Could not find wrap up index: %d\n", wrap_up); // goto error; } goto end; } case CMD_WARNING: logp("WARNING: %s\n", rbuf->cmd); cntr_add(conf->cntr, rbuf->cmd, 0); goto end; case CMD_GEN: if(!strcmp(rbuf->buf, "requests_end")) { *requests_end=1; goto end; } else if(!strcmp(rbuf->buf, "blk_requests_end")) { *blk_requests_end=1; goto end; } else if(!strcmp(rbuf->buf, "backup_end")) { *backup_end=1; goto end; } break; }
uint64_t decode_file_no(struct iobuf *iobuf) { int64_t val; from_base64(&val, iobuf->buf); return (uint64_t)val; }
/* Decode a stat packet from base64 characters */ void decode_stat(const char *buf, struct stat *statp, int64_t *winattr, int *compression) { const char *p = buf; int64_t val; p += from_base64(&val, p); plug(statp->st_dev, val); p++; p += from_base64(&val, p); plug(statp->st_ino, val); p++; p += from_base64(&val, p); plug(statp->st_mode, val); p++; p += from_base64(&val, p); plug(statp->st_nlink, val); p++; p += from_base64(&val, p); plug(statp->st_uid, val); p++; p += from_base64(&val, p); plug(statp->st_gid, val); p++; p += from_base64(&val, p); plug(statp->st_rdev, val); p++; p += from_base64(&val, p); plug(statp->st_size, val); p++; p += from_base64(&val, p); #ifdef HAVE_WIN32 // plug(statp->st_blksize, val); p++; p += from_base64(&val, p); // plug(statp->st_blocks, val); #else plug(statp->st_blksize, val); p++; p += from_base64(&val, p); plug(statp->st_blocks, val); #endif p++; p += from_base64(&val, p); plug(statp->st_atime, val); p++; p += from_base64(&val, p); plug(statp->st_mtime, val); p++; p += from_base64(&val, p); plug(statp->st_ctime, val); /* FreeBSD user flags */ if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; if(!*p) return; p += from_base64(&val, p); #ifdef HAVE_CHFLAGS plug(statp->st_flags, val); } else { statp->st_flags = 0; #endif } /* Look for winattr */ if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; p += from_base64(&val, p); } else { val = 0; } *winattr=val; /* Compression */ if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; if(!*p) return; p += from_base64(&val, p); *compression=val; } else { *compression=-1; } }
static int deal_with_read(struct iobuf *rbuf, struct slist *slist, struct cntr *cntr, uint8_t *end_flags) { int ret=0; switch(rbuf->cmd) { /* Incoming file request. */ case CMD_FILE: case CMD_METADATA: if(add_to_file_requests(slist, rbuf)) goto error; return 0; /* Incoming data block request. */ case CMD_DATA_REQ: if(add_to_data_requests(slist->blist, rbuf)) goto error; goto end; /* Incoming control/message stuff. */ case CMD_WRAP_UP: { int64_t wrap_up; struct blk *blk; struct blist *blist=slist->blist; from_base64(&wrap_up, rbuf->buf); for(blk=blist->head; blk; blk=blk->next) { if(blk->index==(uint64_t)wrap_up) { blist->last_requested=blk; blist->last_sent=blk; break; } } if(!blk) { logp("Could not find wrap up index: %016" PRIX64 "\n", wrap_up); // goto error; } goto end; } case CMD_MESSAGE: case CMD_WARNING: { log_recvd(rbuf, cntr, 0); goto end; } case CMD_GEN: if(!strcmp(rbuf->buf, "requests_end")) { (*end_flags)|=END_REQUESTS; goto end; } else if(!strcmp(rbuf->buf, "blk_requests_end")) { (*end_flags)|=END_BLK_REQUESTS; goto end; } else if(!strcmp(rbuf->buf, "backup_end")) { (*end_flags)|=END_BACKUP; goto end; } break; default: break; } iobuf_log_unexpected(rbuf, __func__); error: ret=-1; end: iobuf_free_content(rbuf); return ret; }
/** Decode a stat packet from base64 characters */ int decode_stat(char *buf, struct stat *statp, int stat_size, int32_t *LinkFI) { char *p = buf; int64_t val; /* * We store into the stat packet so make sure the caller's conception * is the same as ours. They can be different if LARGEFILE is not * the same when compiling this library and the calling program. */ ASSERT(stat_size == (int)sizeof(struct stat)); p += from_base64(&val, p); plug(statp->st_dev, val); p++; p += from_base64(&val, p); plug(statp->st_ino, val); p++; p += from_base64(&val, p); plug(statp->st_mode, val); p++; p += from_base64(&val, p); plug(statp->st_nlink, val); p++; p += from_base64(&val, p); plug(statp->st_uid, val); p++; p += from_base64(&val, p); plug(statp->st_gid, val); p++; p += from_base64(&val, p); plug(statp->st_rdev, val); p++; p += from_base64(&val, p); plug(statp->st_size, val); p++; #ifndef HAVE_MINGW p += from_base64(&val, p); plug(statp->st_blksize, val); p++; p += from_base64(&val, p); plug(statp->st_blocks, val); p++; #else p += from_base64(&val, p); // plug(statp->st_blksize, val); p++; p += from_base64(&val, p); // plug(statp->st_blocks, val); p++; #endif p += from_base64(&val, p); plug(statp->st_atime, val); p++; p += from_base64(&val, p); plug(statp->st_mtime, val); p++; p += from_base64(&val, p); plug(statp->st_ctime, val); /* Optional FileIndex of hard linked file data */ if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; p += from_base64(&val, p); *LinkFI = (uint32_t)val; } else { *LinkFI = 0; return 0; } /* FreeBSD user flags */ if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; p += from_base64(&val, p); #ifdef HAVE_CHFLAGS plug(statp->st_flags, val); } else { statp->st_flags = 0; #endif } /* Look for data stream id */ if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) { p++; p += from_base64(&val, p); } else { val = 0; } return (int)val; }
int unpack_attributes_record(JCR *jcr, int32_t stream, char *rec, int32_t reclen, ATTR *attr) { char *p; int object_len; /* * An Attributes record consists of: * File_index * Type (FT_types) * Filename * Attributes * Link name (if file linked i.e. FT_LNK) * Extended attributes (Win32) * plus optional values determined by AR_ flags in upper bits of Type * Data_stream * */ attr->stream = stream; Dmsg1(dbglvl, "Attr: %s\n", rec); if (sscanf(rec, "%d %d", &attr->file_index, &attr->type) != 2) { Jmsg(jcr, M_FATAL, 0, _("Error scanning attributes: %s\n"), rec); Dmsg1(dbglvl, "\nError scanning attributes. %s\n", rec); return 0; } Dmsg2(dbglvl, "Got Attr: FilInx=%d type=%d\n", attr->file_index, attr->type); /* * Note AR_DATA_STREAM should never be set since it is encoded * at the end of the attributes. */ if (attr->type & AR_DATA_STREAM) { attr->data_stream = 1; } else { attr->data_stream = 0; } attr->type &= FT_MASK; /* keep only type bits */ p = rec; while (*p++ != ' ') /* skip record file index */ { } while (*p++ != ' ') /* skip type */ { } attr->fname = p; /* set filname position */ while (*p++ != 0) /* skip filename */ { } attr->attr = p; /* set attributes position */ while (*p++ != 0) /* skip attributes */ { } attr->lname = p; /* set link position */ while (*p++ != 0) /* skip link */ { } attr->delta_seq = 0; if (attr->type == FT_RESTORE_FIRST) { /* We have an object, so do a binary copy */ object_len = reclen + rec - p; attr->attrEx = check_pool_memory_size(attr->attrEx, object_len + 1); memcpy(attr->attrEx, p, object_len); /* Add a EOS for those who attempt to print the object */ p = attr->attrEx + object_len; *p = 0; } else { pm_strcpy(attr->attrEx, p); /* copy extended attributes, if any */ if (attr->data_stream) { int64_t val; while (*p++ != 0) /* skip extended attributes */ { } from_base64(&val, p); attr->data_stream = (int32_t)val; } else { while (*p++ != 0) /* skip extended attributes */ { } if (p - rec < reclen) { attr->delta_seq = str_to_int32(p); /* delta_seq */ } } } Dmsg8(dbglvl, "unpack_attr FI=%d Type=%d fname=%s attr=%s lname=%s attrEx=%s datastr=%d delta_seq=%d\n", attr->file_index, attr->type, attr->fname, attr->attr, attr->lname, attr->attrEx, attr->data_stream, attr->delta_seq); *attr->ofname = 0; *attr->olname = 0; return 1; }
/** * Set Extended File Attributes for Win32 * * fname is the original filename * ofile is the output filename (may be in a different directory) * * Returns: true on success * false on failure */ static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd) { char *p = attr->attrEx; int64_t val; WIN32_FILE_ATTRIBUTE_DATA atts; ULARGE_INTEGER li; POOLMEM *win32_ofile; /** if we have neither Win ansi nor wchar API, get out */ if (!(p_SetFileAttributesW || p_SetFileAttributesA)) { return false; } if (!p || !*p) { /* we should have attributes */ Dmsg2(100, "Attributes missing. of=%s ofd=%d\n", attr->ofname, ofd->fid); if (is_bopen(ofd)) { bclose(ofd); } return false; } else { Dmsg2(100, "Attribs %s = %s\n", attr->ofname, attr->attrEx); } p += from_base64(&val, p); plug(atts.dwFileAttributes, val); p++; /* skip space */ p += from_base64(&val, p); li.QuadPart = val; atts.ftCreationTime.dwLowDateTime = li.LowPart; atts.ftCreationTime.dwHighDateTime = li.HighPart; p++; /* skip space */ p += from_base64(&val, p); li.QuadPart = val; atts.ftLastAccessTime.dwLowDateTime = li.LowPart; atts.ftLastAccessTime.dwHighDateTime = li.HighPart; p++; /* skip space */ p += from_base64(&val, p); li.QuadPart = val; atts.ftLastWriteTime.dwLowDateTime = li.LowPart; atts.ftLastWriteTime.dwHighDateTime = li.HighPart; p++; p += from_base64(&val, p); plug(atts.nFileSizeHigh, val); p++; p += from_base64(&val, p); plug(atts.nFileSizeLow, val); /** Convert to Windows path format */ win32_ofile = get_pool_memory(PM_FNAME); unix_name_to_win32(&win32_ofile, attr->ofname); /** At this point, we have reconstructed the WIN32_FILE_ATTRIBUTE_DATA pkt */ if (!is_bopen(ofd)) { Dmsg1(100, "File not open: %s\n", attr->ofname); bopen(ofd, attr->ofname, O_WRONLY|O_BINARY, 0); /* attempt to open the file */ } if (is_bopen(ofd)) { Dmsg1(100, "SetFileTime %s\n", attr->ofname); if (!SetFileTime(bget_handle(ofd), &atts.ftCreationTime, &atts.ftLastAccessTime, &atts.ftLastWriteTime)) { win_error(jcr, "SetFileTime:", win32_ofile); } bclose(ofd); } Dmsg1(100, "SetFileAtts %s\n", attr->ofname); if (!(atts.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { if (p_SetFileAttributesW) { POOLMEM* pwszBuf = get_pool_memory(PM_FNAME); make_win32_path_UTF8_2_wchar(&pwszBuf, attr->ofname); BOOL b=p_SetFileAttributesW((LPCWSTR)pwszBuf, atts.dwFileAttributes & SET_ATTRS); free_pool_memory(pwszBuf); if (!b) win_error(jcr, "SetFileAttributesW:", win32_ofile); } else { if (!p_SetFileAttributesA(win32_ofile, atts.dwFileAttributes & SET_ATTRS)) { win_error(jcr, "SetFileAttributesA:", win32_ofile); } } } free_pool_memory(win32_ofile); return true; }
int main(int argc, char **argv) { pool p[1] = { pool_create() }; assert(argc == CIPHERS + 1); byteblock cts[CIPHERS]; argc--; argv++; for (int i = 0; i < argc; i++) { byteblock plain = from_base64(p, argv[i]); cts[i] = rijndael_ctr_process(p, &key, &nonce, &plain); } /* build a table of probablities of key values */ int guesses[GUESSLEN][256] = { { 0 } }; for (size_t i = 0; i < GUESSLEN; i++) { for (int guess = 0; guess < 256; guess++) { for (size_t sample = 0; sample < CIPHERS; sample++) { if (cts[sample].len >= i) { int result = guess ^ cts[sample].buf[i]; guesses[i][guess] += score_english_char(result); } } } } /* construct the key from the highest probability values */ uint8_t key[GUESSLEN]; for (size_t i = 0; i < GUESSLEN; i++) { uint8_t best; int best_score = 0xffff; for (int guess = 0; guess < 256; guess++) { if (guesses[i][guess] < best_score) { best = guess; best_score = guesses[i][guess]; } } key[i] = best; } /* now decrypt and print */ for (size_t i = 0; i < GUESSLEN; i++) { if (i >= cts[ATTACK].len) break; printf("%c", cts[ATTACK].buf[i] ^ key[i]); } printf("\n"); p->finish(p); return 0; }