static void append_fingerprint (GcrCertificateDetailsWidget *self, const guchar *data, gsize n_data, const gchar *name, GChecksumType type) { GChecksum *checksum; guint8 *buffer; gsize n_buffer; gchar *display; checksum = g_checksum_new (type); g_return_if_fail (checksum); g_checksum_update (checksum, data, n_data); n_buffer = g_checksum_type_get_length (type); g_return_if_fail (n_buffer); buffer = g_malloc0 (n_buffer); g_checksum_get_digest (checksum, buffer, &n_buffer); g_checksum_free (checksum); display = egg_hex_encode_full (buffer, n_buffer, TRUE, ' ', 1); append_field_and_value (self, name, display, TRUE); g_free (display); g_free (buffer); }
static void chap_process_challenge(struct ppp_chap *chap, const guint8 *packet) { const struct chap_header *header = (const struct chap_header *) packet; struct chap_header *response; GChecksum *checksum; const char *secret = g_at_ppp_get_password(chap->ppp); const char *username = g_at_ppp_get_username(chap->ppp); guint16 response_length; struct ppp_header *ppp_packet; gsize digest_len; /* create a checksum over id, secret, and challenge */ checksum = g_checksum_new(chap->method); if (checksum == NULL) return; g_checksum_update(checksum, &header->identifier, 1); if (secret) g_checksum_update(checksum, (guchar *) secret, strlen(secret)); g_checksum_update(checksum, &header->data[1], header->data[0]); /* transmit a response packet */ /* * allocate space for the header, the checksum, and the ppp header, * and the value size byte */ digest_len = g_checksum_type_get_length(chap->method); response_length = digest_len + sizeof(*header) + 1; if (username != NULL) response_length += strlen(username); ppp_packet = ppp_packet_new(response_length, CHAP_PROTOCOL); if (ppp_packet == NULL) goto challenge_out; response = (struct chap_header *) &ppp_packet->info; if (response) { response->code = RESPONSE; response->identifier = header->identifier; response->length = htons(response_length); g_checksum_get_digest(checksum, response->data + 1, &digest_len); response->data[0] = digest_len; /* leave the name empty? */ } if (username != NULL) memcpy(response->data + digest_len + 1, username, strlen(username)); /* transmit the packet */ ppp_transmit(chap->ppp, (guint8 *) ppp_packet, response_length); g_free(ppp_packet); challenge_out: g_checksum_free(checksum); }
static uint8_t *digest_cert(const char *cert, int length) { GChecksum *checksum; uint8_t *hash; gsize digest_len; if (cert == NULL || length < 0) return NULL; digest_len = g_checksum_type_get_length(G_CHECKSUM_SHA1); hash = g_try_malloc(digest_len); if (hash == NULL) return NULL; checksum = g_checksum_new(G_CHECKSUM_SHA1); if (checksum == NULL) { g_free(hash); return NULL; } g_checksum_update(checksum, cert, length); g_checksum_get_digest(checksum, hash, &digest_len); DBG("Digest is: "); __seel_apdu_dump(hash, digest_len); g_checksum_free(checksum); return hash; }
/** * gcr_fingerprint_from_subject_public_key_info: * @key_info: (array length=n_key_info): DER encoded subjectPublicKeyInfo structure * @n_key_info: length of DER encoded structure * @checksum_type: the type of fingerprint to create * @n_fingerprint: the length of fingerprint returned * * Create a key fingerprint for a DER encoded subjectPublicKeyInfo. * * Returns: (transfer full) (allow-none) (array length=n_fingerprint): the * fingerprint or %NULL if the input was invalid. */ guchar * gcr_fingerprint_from_subject_public_key_info (const guchar *key_info, gsize n_key_info, GChecksumType checksum_type, gsize *n_fingerprint) { GChecksum *check; guint8 *fingerprint; g_return_val_if_fail (key_info, NULL); g_return_val_if_fail (n_key_info, NULL); g_return_val_if_fail (n_fingerprint, NULL); check = g_checksum_new (checksum_type); g_return_val_if_fail (check, NULL); g_checksum_update (check, key_info, n_key_info); *n_fingerprint = g_checksum_type_get_length (checksum_type); fingerprint = g_malloc (*n_fingerprint); g_checksum_get_digest (check, fingerprint, n_fingerprint); g_checksum_free (check); return fingerprint; }
sc_bool sc_link_calculate_checksum(const sc_stream *stream, sc_check_sum *check_sum) { sc_char buffer[1024]; sc_uint32 data_read; const gchar *result = 0; GChecksum *checksum = g_checksum_new(SC_DEFAULT_CHECKSUM); g_assert(stream != 0); g_assert(check_sum != 0); g_checksum_reset(checksum); sc_stream_seek(stream, SC_STREAM_SEEK_SET, 0); while (sc_stream_eof(stream) == SC_FALSE) { if (sc_stream_read_data(stream, buffer, 1024, &data_read) == SC_RESULT_ERROR) { g_checksum_free(checksum); return SC_FALSE; } g_checksum_update(checksum, (guchar*)buffer, data_read); } // store results check_sum->len = g_checksum_type_get_length(SC_DEFAULT_CHECKSUM); result = g_checksum_get_string(checksum); memcpy(&(check_sum->data[0]), result, check_sum->len); g_checksum_free(checksum); sc_stream_seek(stream, SC_STREAM_SEEK_SET, 0); return SC_TRUE; }
/** * CacheUtilHashPassword: * @algorithm: Hash algorithm. * @salt: Random data, usually stored with the hash. * @password: Secret value to hash. * * Returns: (allow-none): Hash value of concatenated @salt and @password, or * #NULL if an argument was invalid. */ GBytes *CacheUtilHashPassword(GChecksumType algorithm, GBytes *salt, const char *password) { GChecksum *checksum = NULL; gssize checksum_len = -1; guint8 *result = NULL; gsize result_len = 0; if (!salt || !password) return NULL; checksum_len = g_checksum_type_get_length(algorithm); if (checksum_len <= 0) return NULL; checksum = g_checksum_new(algorithm); if (!checksum) return NULL; g_checksum_update( checksum, g_bytes_get_data(salt, NULL), g_bytes_get_size(salt)); g_checksum_update(checksum, (guint8 *) password, strlen(password)); result = g_malloc(checksum_len); result_len = checksum_len; g_checksum_get_digest(checksum, result, &result_len); g_assert(checksum_len == result_len); g_checksum_free(checksum); return g_bytes_new_take(result, result_len); }
void _gcr_display_view_append_fingerprint (GcrDisplayView *self, GcrRenderer *renderer, const guchar *data, gsize n_data, const gchar *name, GChecksumType type) { GChecksum *checksum; guint8 *buffer; gsize n_buffer; gchar *display; g_return_if_fail (GCR_IS_DISPLAY_VIEW (self)); checksum = g_checksum_new (type); g_return_if_fail (checksum); g_checksum_update (checksum, data, n_data); n_buffer = g_checksum_type_get_length (type); g_return_if_fail (n_buffer); buffer = g_malloc0 (n_buffer); g_checksum_get_digest (checksum, buffer, &n_buffer); g_checksum_free (checksum); display = egg_hex_encode_full (buffer, n_buffer, TRUE, ' ', 1); _gcr_display_view_append_value (self, renderer, name, display, TRUE); g_free (display); g_free (buffer); }
gchar * kms_utils_generate_fingerprint_from_pem (const gchar * pem) { guint i; gchar *line; guchar *der, *tmp; gchar **lines; gint state = 0; guint save = 0; gsize der_length = 0; GChecksum *checksum; guint8 *digest; gsize digest_length; GString *fingerprint; gchar *ret; if (pem == NULL) { GST_ERROR ("Pem certificate is null"); return NULL; } der = tmp = g_new0 (guchar, (strlen (pem) / 4) * 3 + 3); lines = g_strsplit (pem, "\n", 0); for (i = 0, line = lines[i]; line; line = lines[++i]) { if (line[0] && g_str_has_prefix (line, BEGIN_CERTIFICATE)) { i++; break; } } for (line = lines[i]; line; line = lines[++i]) { if (line[0] && g_str_has_prefix (line, END_CERTIFICATE)) { break; } tmp += g_base64_decode_step (line, strlen (line), tmp, &state, &save); } der_length = tmp - der; checksum = g_checksum_new (G_CHECKSUM_SHA256); digest_length = g_checksum_type_get_length (G_CHECKSUM_SHA256); digest = g_new (guint8, digest_length); g_checksum_update (checksum, der, der_length); g_checksum_get_digest (checksum, digest, &digest_length); fingerprint = g_string_new (NULL); for (i = 0; i < digest_length; i++) { if (i) g_string_append (fingerprint, ":"); g_string_append_printf (fingerprint, "%02X", digest[i]); } ret = g_string_free (fingerprint, FALSE); g_free (digest); g_checksum_free (checksum); g_free (der); g_strfreev (lines); return ret; }
static uint8_t *hash (const void *buffer, size_t size, uint8_t *out, GChecksumType type) { GChecksum *s = g_checksum_new(type); gsize digest_size = g_checksum_type_get_length(type); g_checksum_update(s, buffer, size); g_checksum_get_digest(s, out, &digest_size); g_checksum_free(s); return out; }
/** * g_hmac_get_digest: * @hmac: a #GHmac * @buffer: (array length=digest_len): output buffer * @digest_len: (inout): an inout parameter. The caller initializes it to the * size of @buffer. After the call it contains the length of the digest * * Gets the digest from @checksum as a raw binary array and places it * into @buffer. The size of the digest depends on the type of checksum. * * Once this function has been called, the #GHmac is closed and can * no longer be updated with g_checksum_update(). * * Since: 2.30 */ void g_hmac_get_digest (GHmac *hmac, guint8 *buffer, gsize *digest_len) { gsize len; g_return_if_fail (hmac != NULL); len = g_checksum_type_get_length (hmac->digest_type); g_return_if_fail (*digest_len >= len); /* Use the same buffer, because we can :) */ g_checksum_get_digest (hmac->digesti, buffer, &len); g_checksum_update (hmac->digesto, buffer, len); g_checksum_get_digest (hmac->digesto, buffer, digest_len); }
static guint8 * get_md5_digest (const guchar *str) { guint8 *digest; gsize length; GChecksum *checksum; length = g_checksum_type_get_length (G_CHECKSUM_MD5); digest = g_malloc0 (length); checksum = g_checksum_new (G_CHECKSUM_MD5); g_checksum_update (checksum, str, -1); g_checksum_get_digest (checksum, digest, &length); g_checksum_free (checksum); return digest; }
static GBytes * hash_sha1 (GBytes *data) { GChecksum *checksum; guchar *hash; gsize n_hash; n_hash = g_checksum_type_get_length (G_CHECKSUM_SHA1); hash = g_malloc (n_hash); checksum = g_checksum_new (G_CHECKSUM_SHA1); g_checksum_update (checksum, g_bytes_get_data (data, NULL), g_bytes_get_size (data)); g_checksum_get_digest (checksum, hash, &n_hash); g_checksum_free (checksum); return g_bytes_new_take (hash, n_hash); }
/** * g_hmac_get_string: * @hmac: a #GHmac * * Gets the HMAC as an hexadecimal string. * * Once this function has been called the #GHmac can no longer be * updated with g_hmac_update(). * * The hexadecimal characters will be lower case. * * Returns: the hexadecimal representation of the HMAC. The * returned string is owned by the HMAC and should not be modified * or freed. * * Since: 2.30 */ const gchar * g_hmac_get_string (GHmac *hmac) { guint8 *buffer; gsize digest_len; g_return_val_if_fail (hmac != NULL, NULL); digest_len = g_checksum_type_get_length (hmac->digest_type); buffer = g_alloca (digest_len); /* This is only called for its side-effect of updating hmac->digesto... */ g_hmac_get_digest (hmac, buffer, &digest_len); /* ... because we get the string from the checksum rather than * stringifying buffer ourselves */ return g_checksum_get_string (hmac->digesto); }
static GError * _checksum_file (const char *path, struct file_info_s *fi) { GError *err = NULL; gchar *file_content = NULL; g_file_get_contents (path, &file_content, &fi->fs, &err); if (err) return err; fi->hs = g_checksum_type_get_length (G_CHECKSUM_SHA256); GChecksum *checksum = g_checksum_new (G_CHECKSUM_SHA256); g_checksum_update (checksum, (guint8*)file_content, fi->fs); g_checksum_get_digest (checksum, fi->h, &fi->hs); g_checksum_free (checksum); g_free (file_content); return NULL; }
static gchar * generate_fingerprint_from_pem (const gchar * pem) { guint i; gchar *line; guchar *der, *tmp; gchar **lines; gint state = 0; guint save = 0; gsize der_length = 0; GChecksum *checksum; guint8 *digest; gsize digest_length; GString *fingerprint; gchar *ret; der = tmp = g_new0 (guchar, (strlen (pem) / 4) * 3 + 3); lines = g_strsplit (pem, "\n", 0); for (i = 0, line = lines[i]; line; line = lines[++i]) { if (line[0] && !g_str_has_prefix (line, "-----")) tmp += g_base64_decode_step (line, strlen (line), tmp, &state, &save); } der_length = tmp - der; checksum = g_checksum_new (G_CHECKSUM_SHA256); digest_length = g_checksum_type_get_length (G_CHECKSUM_SHA256); digest = g_new (guint8, digest_length); g_checksum_update (checksum, der, der_length); g_checksum_get_digest (checksum, digest, &digest_length); fingerprint = g_string_new (NULL); for (i = 0; i < digest_length; i++) { if (i) g_string_append (fingerprint, ":"); g_string_append_printf (fingerprint, "%02X", digest[i]); } ret = g_string_free (fingerprint, FALSE); g_free (digest); g_checksum_free (checksum); g_free (der); g_strfreev (lines); return ret; }
void got_dtls_certificate(GObject *media_session, GParamSpec *pspec, gpointer user_data) { guint i; gchar *pem, *line; guchar *der, *tmp; gchar **lines; gint state = 0; guint save = 0; gsize der_length = 0; GChecksum *checksum; guint8 *digest; gsize digest_length; GString *fingerprint; g_object_get(media_session, "dtls-certificate", &pem, NULL); der = tmp = g_new0(guchar, (strlen(pem) / 4) * 3 + 3); lines = g_strsplit(pem, "\n", 0); for (i = 0, line = lines[i]; line; line = lines[++i]) { if (line[0] && !g_str_has_prefix(line, "-----")) tmp += g_base64_decode_step(line, strlen(line), tmp, &state, &save); } der_length = tmp - der; checksum = g_checksum_new(G_CHECKSUM_SHA256); digest_length = g_checksum_type_get_length(G_CHECKSUM_SHA256); digest = g_new(guint8, digest_length); g_checksum_update(checksum, der, der_length); g_checksum_get_digest(checksum, digest, &digest_length); fingerprint = g_string_new(NULL); for (i = 0; i < digest_length; i++) { if (i) g_string_append(fingerprint, ":"); g_string_append_printf(fingerprint, "%02X", digest[i]); } gchar *fprint = g_string_free(fingerprint, FALSE); got_dtls_certificate_go(OWR_SESSION(media_session), fprint); g_free(fprint); g_free(digest); g_checksum_free(checksum); g_free(der); g_strfreev(lines); }
static void multipart_set_boundary (CamelMultipart *multipart, const gchar *boundary) { CamelDataWrapper *cdw = CAMEL_DATA_WRAPPER (multipart); gchar *bgen, bbuf[27], *p; guint8 *digest; gsize length; gint state, save; g_return_if_fail (cdw->mime_type != NULL); length = g_checksum_type_get_length (G_CHECKSUM_MD5); digest = g_alloca (length); if (!boundary) { GChecksum *checksum; /* Generate a fairly random boundary string. */ bgen = g_strdup_printf ("%p:%lu:%lu", (gpointer) multipart, (gulong) getpid (), (gulong) time (NULL)); checksum = g_checksum_new (G_CHECKSUM_MD5); g_checksum_update (checksum, (guchar *) bgen, -1); g_checksum_get_digest (checksum, digest, &length); g_checksum_free (checksum); g_free (bgen); strcpy (bbuf, "=-"); p = bbuf + 2; state = save = 0; p += g_base64_encode_step ( (guchar *) digest, length, FALSE, p, &state, &save); *p = '\0'; boundary = bbuf; } camel_content_type_set_param (cdw->mime_type, "boundary", boundary); }
/** * gcr_certificate_get_fingerprint: * @self: a #GcrCertificate * @type: the type of algorithm for the fingerprint. * @n_length: The length of the resulting fingerprint. * * Calculate the fingerprint for this certificate. * * You can pass G_CHECKSUM_SHA1 or G_CHECKSUM_MD5 as the @type * parameter. * * The caller should free the returned data using g_free() when * it is no longer required. * * Returns: the raw binary fingerprint. **/ guchar* gcr_certificate_get_fingerprint (GcrCertificate *self, GChecksumType type, gsize *n_length) { GChecksum *sum; guchar *digest; gssize length; g_return_val_if_fail (GCR_IS_CERTIFICATE (self), NULL); g_return_val_if_fail (n_length, NULL); sum = digest_certificate (self, type); g_return_val_if_fail (sum, NULL); length = g_checksum_type_get_length (type); g_return_val_if_fail (length > 0, NULL); digest = g_malloc (length); *n_length = length; g_checksum_get_digest (sum, digest, n_length); g_checksum_free (sum); return digest; }
/** * e_dbhash_add: * @edbh: an #EDbHash * @key: a database key * @data: a database object for @key * * Adds a database object for @key. **/ void e_dbhash_add (EDbHash *edbh, const gchar *key, const gchar *data) { DB *db; DBT dkey; DBT ddata; GChecksum *checksum; guint8 *digest; gsize length; g_return_if_fail (edbh != NULL); g_return_if_fail (edbh->priv != NULL); g_return_if_fail (edbh->priv->db != NULL); g_return_if_fail (key != NULL); g_return_if_fail (data != NULL); length = g_checksum_type_get_length (G_CHECKSUM_MD5); digest = g_alloca (length); db = edbh->priv->db; /* Key dbt */ string_to_dbt (key, &dkey); /* Compute MD5 checksum */ checksum = g_checksum_new (G_CHECKSUM_MD5); g_checksum_update (checksum, (guchar *) data, -1); g_checksum_get_digest (checksum, digest, &length); g_checksum_free (checksum); /* Data dbt */ md5_to_dbt (digest, &ddata); /* Add to database */ db->put (db, NULL, &dkey, &ddata, 0); }
/** * gcr_certificate_get_fingerprint_hex: * @self: a #GcrCertificate * @type: the type of algorithm for the fingerprint. * * Calculate the fingerprint for this certificate, and return it * as a hex string. * * You can pass G_CHECKSUM_SHA1 or G_CHECKSUM_MD5 as the @type * parameter. * * The caller should free the returned data using g_free() when * it is no longer required. * * Returns: an allocated hex string which contains the fingerprint. */ gchar* gcr_certificate_get_fingerprint_hex (GcrCertificate *self, GChecksumType type) { GChecksum *sum; guchar *digest; gsize n_digest; gssize length; gchar *hex; g_return_val_if_fail (GCR_IS_CERTIFICATE (self), NULL); sum = digest_certificate (self, type); g_return_val_if_fail (sum, NULL); length = g_checksum_type_get_length (type); g_return_val_if_fail (length > 0, NULL); digest = g_malloc (length); n_digest = length; g_checksum_get_digest (sum, digest, &n_digest); hex = egg_hex_encode_full (digest, n_digest, TRUE, ' ', 1); g_checksum_free (sum); g_free (digest); return hex; }
static int qcrypto_glib_hmac_bytesv(QCryptoHmac *hmac, const struct iovec *iov, size_t niov, uint8_t **result, size_t *resultlen, Error **errp) { QCryptoHmacGlib *ctx; int i, ret; ctx = hmac->opaque; for (i = 0; i < niov; i++) { g_hmac_update(ctx->ghmac, iov[i].iov_base, iov[i].iov_len); } ret = g_checksum_type_get_length(qcrypto_hmac_alg_map[hmac->alg]); if (ret < 0) { error_setg(errp, "Unable to get hmac length"); return -1; } if (*resultlen == 0) { *resultlen = ret; *result = g_new0(uint8_t, *resultlen); } else if (*resultlen != ret) { error_setg(errp, "Result buffer size %zu is smaller than hmac %d", *resultlen, ret); return -1; } g_hmac_get_digest(ctx->ghmac, *result, resultlen); return 0; }
static GBytes * hash_sha1_pkcs1 (GBytes *data) { const guchar SHA1_ASN[15] = /* Object ID is 1.3.14.3.2.26 */ { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 }; GChecksum *checksum; guchar *hash; gsize n_hash; gsize n_digest; n_digest = g_checksum_type_get_length (G_CHECKSUM_SHA1); n_hash = n_digest + sizeof (SHA1_ASN); hash = g_malloc (n_hash); memcpy (hash, SHA1_ASN, sizeof (SHA1_ASN)); checksum = g_checksum_new (G_CHECKSUM_SHA1); g_checksum_update (checksum, g_bytes_get_data (data, NULL), g_bytes_get_size (data)); g_checksum_get_digest (checksum, hash + sizeof (SHA1_ASN), &n_digest); g_checksum_free (checksum); return g_bytes_new_take (hash, n_hash); }
static gboolean purple_sha1_hash_digest(PurpleHash *hash, guchar *digest, size_t buff_len) { PurpleSHA1Hash *sha1_hash = PURPLE_SHA1_HASH(hash); PurpleSHA1HashPrivate *priv = PURPLE_SHA1_HASH_GET_PRIVATE(sha1_hash); const gssize required_len = g_checksum_type_get_length(G_CHECKSUM_SHA1); gsize digest_len = buff_len; g_return_val_if_fail(priv != NULL, FALSE); g_return_val_if_fail(priv->checksum != NULL, FALSE); g_return_val_if_fail(required_len >= 0, FALSE); g_return_val_if_fail(buff_len >= (gsize)required_len, FALSE); g_checksum_get_digest(priv->checksum, digest, &digest_len); if (digest_len != (gsize)required_len) return FALSE; purple_sha1_hash_reset(hash); return TRUE; }
static void _tgentransfer_readChecksum(TGenTransfer* transfer) { TGEN_ASSERT(transfer); if(_tgentransfer_getLine(transfer)) { /* transfer is done */ _tgentransfer_changeState(transfer, TGEN_XFER_SUCCESS); transfer->time.checksum = g_get_monotonic_time(); /* we have read the entire checksum from the other end */ gssize sha1Length = g_checksum_type_get_length(G_CHECKSUM_MD5); g_assert(sha1Length >= 0); gchar* computedSum = g_strdup(g_checksum_get_string(transfer->payloadChecksum)); gchar* line = g_string_free(transfer->readBuffer, FALSE); transfer->readBuffer = NULL; gchar** parts = g_strsplit(line, " ", 0); const gchar* receivedSum = parts[1]; g_assert(receivedSum); /* check that the sums match */ if(!g_ascii_strncasecmp(computedSum, receivedSum, (gsize)sha1Length)) { tgen_message("transport %s transfer %s MD5 checksums passed: computed=%s received=%s", tgentransport_toString(transfer->transport), _tgentransfer_toString(transfer), computedSum, receivedSum); } else { tgen_message("MD5 checksums failed: computed=%s received=%s", computedSum, receivedSum); } g_strfreev(parts); g_free(line); g_free(computedSum); } else { /* unable to receive entire checksum, wait for next chance to read */ } }
/* Fd must be opened for writing, after creating file is mmapped */ static gboolean create_cache_file (struct symbols_cache *cache, const gchar *filename, gint fd, rspamd_mempool_t *pool) { GChecksum *cksum; u_char *digest; gsize cklen; GList *cur; struct cache_item *item; /* Calculate checksum */ cksum = get_mem_cksum (cache); if (cksum == NULL) { msg_err ("cannot calculate checksum for symbols"); close (fd); return FALSE; } cklen = g_checksum_type_get_length (G_CHECKSUM_SHA1); digest = g_malloc (cklen); g_checksum_get_digest (cksum, digest, &cklen); /* Now write data to file */ cur = g_list_first (cache->negative_items); while (cur) { item = cur->data; if (write (fd, item->s, sizeof (struct saved_cache_item)) == -1) { msg_err ("cannot write to file %d, %s", errno, strerror (errno)); close (fd); g_checksum_free (cksum); g_free (digest); return FALSE; } cur = g_list_next (cur); } cur = g_list_first (cache->static_items); while (cur) { item = cur->data; if (write (fd, item->s, sizeof (struct saved_cache_item)) == -1) { msg_err ("cannot write to file %d, %s", errno, strerror (errno)); close (fd); g_checksum_free (cksum); g_free (digest); return FALSE; } cur = g_list_next (cur); } /* Write checksum */ if (write (fd, digest, cklen) == -1) { msg_err ("cannot write to file %d, %s", errno, strerror (errno)); close (fd); g_checksum_free (cksum); g_free (digest); return FALSE; } close (fd); g_checksum_free (cksum); g_free (digest); /* Reopen for reading */ if ((fd = open (filename, O_RDWR)) == -1) { msg_info ("cannot open file %s, error %d, %s", errno, strerror (errno)); return FALSE; } return mmap_cache_file (cache, fd, pool); }
static size_t purple_sha1_hash_get_digest_size(PurpleHash *hash) { return g_checksum_type_get_length(G_CHECKSUM_SHA1); }
int main(int argc, char *argv[]) { sc_uint item = -1; fflush(stdout); timer = g_timer_new(); g_timer_start(timer); printf("MD5: %d\n", g_checksum_type_get_length(G_CHECKSUM_MD5) ); printf("SHA1: %d\n", g_checksum_type_get_length(G_CHECKSUM_SHA1) ); printf("SHA256: %d\n", g_checksum_type_get_length(G_CHECKSUM_SHA256) ); sc_storage_initialize("repo"); g_timer_stop(timer); printf("Segment loading speed: %f seg/sec\n", sc_storage_get_segments_count() / g_timer_elapsed(timer, 0)); //test5(); //test6(); //test7(); while (item != 0) { printf("Commands:\n" "0 - exit\n" "1 - test allocation\n" "2 - test sc-addr utilities\n" "3 - test arc deletion\n" "4 - test iterators\n" "5 - test contents\n" "6 - test content finding\n" "7 - test events\n" "\nCommand: "); scanf("%d", &item); printf("\n----- Test %d -----\n", item); switch(item) { case 1: test1(); break; case 2: test2(); break; case 3: test3(); break; case 4: test4(); break; case 5: test5(); break; case 6: test6(); break; case 7: test7(); break; }; printf("\n----- Finished -----\n"); } timer = g_timer_new(); item = sc_storage_get_segments_count(); g_timer_reset(timer); // crash when uncomment sc_storage_shutdown(); g_timer_stop(timer); printf("Segments save speed: %f seg/sec\n", item / g_timer_elapsed(timer, 0)); g_timer_destroy(timer); return 0; }
sc_uint8 _checksum_get_size() { return (sc_uint8)g_checksum_type_get_length(_checksum_type()); }
static GByteArray * cram_md5_challenge (CamelSasl *sasl, GByteArray *token, CamelException *ex) { GChecksum *checksum; guint8 *digest; gsize length; char *passwd; const gchar *hex; GByteArray *ret = NULL; guchar ipad[64]; guchar opad[64]; int i, pw_len; /* Need to wait for the server */ if (!token) return NULL; g_return_val_if_fail (sasl->service->url->passwd != NULL, NULL); length = g_checksum_type_get_length (G_CHECKSUM_MD5); digest = g_alloca (length); memset (ipad, 0, sizeof (ipad)); memset (opad, 0, sizeof (opad)); passwd = sasl->service->url->passwd; pw_len = strlen (passwd); if (pw_len <= 64) { memcpy (ipad, passwd, pw_len); memcpy (opad, passwd, pw_len); } else { checksum = g_checksum_new (G_CHECKSUM_MD5); g_checksum_update (checksum, (guchar *) passwd, pw_len); g_checksum_get_digest (checksum, digest, &length); g_checksum_free (checksum); memcpy (ipad, digest, length); memcpy (opad, digest, length); } for (i = 0; i < 64; i++) { ipad[i] ^= 0x36; opad[i] ^= 0x5c; } checksum = g_checksum_new (G_CHECKSUM_MD5); g_checksum_update (checksum, (guchar *) ipad, sizeof (ipad)); g_checksum_update (checksum, (guchar *) token->data, token->len); g_checksum_get_digest (checksum, digest, &length); g_checksum_free (checksum); checksum = g_checksum_new (G_CHECKSUM_MD5); g_checksum_update (checksum, (guchar *) opad, sizeof (opad)); g_checksum_update (checksum, (guchar *) digest, length); /* String is owned by the checksum. */ hex = g_checksum_get_string (checksum); ret = g_byte_array_new (); g_byte_array_append (ret, (guint8 *) sasl->service->url->user, strlen (sasl->service->url->user)); g_byte_array_append (ret, (guint8 *) " ", 1); g_byte_array_append (ret, (guint8 *) hex, strlen (hex)); g_checksum_free (checksum); sasl->authenticated = TRUE; return ret; }
static RejillaBurnResult rejilla_checksum_files_check_files (RejillaChecksumFiles *self, GError **error) { GValue *value; guint file_nb; guint file_num; gint checksum_len; RejillaVolSrc *vol; goffset start_block; RejillaTrack *track; const gchar *device; RejillaVolFile *file; RejillaDrive *drive; RejillaMedium *medium; GChecksumType gchecksum_type; GArray *wrong_checksums = NULL; RejillaDeviceHandle *dev_handle; RejillaChecksumFilesPrivate *priv; RejillaVolFileHandle *handle = NULL; RejillaBurnResult result = REJILLA_BURN_OK; priv = REJILLA_CHECKSUM_FILES_PRIVATE (self); /* get medium */ rejilla_job_get_current_track (REJILLA_JOB (self), &track); drive = rejilla_track_disc_get_drive (REJILLA_TRACK_DISC (track)); medium = rejilla_drive_get_medium (drive); /* open volume */ if (!rejilla_medium_get_last_data_track_address (medium, NULL, &start_block)) return REJILLA_BURN_ERR; device = rejilla_drive_get_device (rejilla_medium_get_drive (medium)); dev_handle = rejilla_device_handle_open (device, FALSE, NULL); if (!dev_handle) return REJILLA_BURN_ERROR; vol = rejilla_volume_source_open_device_handle (dev_handle, error); /* open checksum file */ file = rejilla_checksum_files_get_on_disc_checksum_type (self, vol, start_block); if (!file) { g_set_error (error, REJILLA_BURN_ERROR, REJILLA_BURN_ERROR_GENERAL, _("No checksum file could be found on the disc")); REJILLA_JOB_LOG (self, "No checksum file"); result = REJILLA_BURN_ERR; goto end; } handle = rejilla_volume_file_open (vol, file); if (!handle) { REJILLA_JOB_LOG (self, "Cannot open checksum file"); /* FIXME: error here ? */ result = REJILLA_BURN_ERR; goto end; } /* get the number of files at this time and rewind */ file_nb = rejilla_checksum_files_get_line_num (self, handle); if (file_nb == 0) { REJILLA_JOB_LOG (self, "Empty checksum file"); result = REJILLA_BURN_OK; goto end; } if (file_nb < 0) { /* An error here */ REJILLA_JOB_LOG (self, "Failed to retrieve the number of lines"); result = REJILLA_BURN_ERR; goto end; } /* signal we're ready to start */ file_num = 0; rejilla_job_set_current_action (REJILLA_JOB (self), REJILLA_BURN_ACTION_CHECKSUM, _("Checking file integrity"), TRUE); rejilla_job_start_progress (REJILLA_JOB (self), FALSE); /* Get the checksum type */ switch (priv->checksum_type) { case REJILLA_CHECKSUM_MD5_FILE: gchecksum_type = G_CHECKSUM_MD5; break; case REJILLA_CHECKSUM_SHA1_FILE: gchecksum_type = G_CHECKSUM_SHA1; break; case REJILLA_CHECKSUM_SHA256_FILE: gchecksum_type = G_CHECKSUM_SHA256; break; default: gchecksum_type = G_CHECKSUM_MD5; break; } checksum_len = g_checksum_type_get_length (gchecksum_type) * 2; while (1) { gchar file_path [MAXPATHLEN + 1]; gchar checksum_file [512 + 1]; RejillaVolFile *disc_file; gchar *checksum_real; gint read_bytes; if (priv->cancel) break; /* first read the checksum */ read_bytes = rejilla_volume_file_read (handle, checksum_file, checksum_len); if (read_bytes == 0) break; if (read_bytes != checksum_len) { /* FIXME: an error here */ REJILLA_JOB_LOG (self, "Impossible to read the checksum from file"); result = REJILLA_BURN_ERR; break; } checksum_file [checksum_len] = '\0'; if (priv->cancel) break; /* skip spaces in between */ while (1) { gchar c [2]; read_bytes = rejilla_volume_file_read (handle, c, 1); if (read_bytes == 0) { result = REJILLA_BURN_OK; goto end; } if (read_bytes < 0) { /* FIXME: an error here */ REJILLA_JOB_LOG (self, "Impossible to read checksum file"); result = REJILLA_BURN_ERR; goto end; } if (!isspace (c [0])) { file_path [0] = '/'; file_path [1] = c [0]; break; } } /* get the filename */ result = rejilla_volume_file_read_line (handle, file_path + 2, sizeof (file_path) - 2); /* FIXME: an error here */ if (result == REJILLA_BURN_ERR) { REJILLA_JOB_LOG (self, "Impossible to read checksum file"); break; } checksum_real = NULL; /* get the file handle itself */ REJILLA_JOB_LOG (self, "Getting file %s", file_path); disc_file = rejilla_volume_get_file (vol, file_path, start_block, NULL); if (!disc_file) { g_set_error (error, REJILLA_BURN_ERROR, REJILLA_BURN_ERROR_GENERAL, _("File \"%s\" could not be opened"), file_path); result = REJILLA_BURN_ERR; break; } /* we certainly don't want to checksum anything but regular file * if (!g_file_test (filename, G_FILE_TEST_IS_REGULAR)) { * rejilla_volume_file_free (disc_file); * continue; * } */ /* checksum the file */ result = rejilla_checksum_files_sum_on_disc_file (self, gchecksum_type, vol, disc_file, &checksum_real, error); rejilla_volume_file_free (disc_file); if (result == REJILLA_BURN_ERR) { g_set_error (error, REJILLA_BURN_ERROR, REJILLA_BURN_ERROR_GENERAL, _("File \"%s\" could not be opened"), file_path); break; } if (result != REJILLA_BURN_OK) break; file_num++; rejilla_job_set_progress (REJILLA_JOB (self), (gdouble) file_num / (gdouble) file_nb); REJILLA_JOB_LOG (self, "comparing checksums for file %s : %s (from md5 file) / %s (current)", file_path, checksum_file, checksum_real); if (strcmp (checksum_file, checksum_real)) { gchar *string; REJILLA_JOB_LOG (self, "Wrong checksum"); if (!wrong_checksums) wrong_checksums = g_array_new (TRUE, TRUE, sizeof (gchar *)); string = g_strdup (file_path); wrong_checksums = g_array_append_val (wrong_checksums, string); } g_free (checksum_real); if (priv->cancel) break; } end: if (handle) rejilla_volume_file_close (handle); if (file) rejilla_volume_file_free (file); if (vol) rejilla_volume_source_close (vol); if (dev_handle) rejilla_device_handle_close (dev_handle); if (result != REJILLA_BURN_OK) { REJILLA_JOB_LOG (self, "Ended with an error"); if (wrong_checksums) { g_strfreev ((gchar **) wrong_checksums->data); g_array_free (wrong_checksums, FALSE); } return result; } if (!wrong_checksums) return REJILLA_BURN_OK; /* add the tag */ value = g_new0 (GValue, 1); g_value_init (value, G_TYPE_STRV); g_value_take_boxed (value, wrong_checksums->data); g_array_free (wrong_checksums, FALSE); rejilla_track_tag_add (track, REJILLA_TRACK_MEDIUM_WRONG_CHECKSUM_TAG, value); g_set_error (error, REJILLA_BURN_ERROR, REJILLA_BURN_ERROR_BAD_CHECKSUM, _("Some files may be corrupted on the disc")); return REJILLA_BURN_ERR; }