/
githubmirror
/
ipxe
Обзор
Документация
Войти
/
githubmirror
/
ipxe
Код
Запросы
0
Пакеты
0
Релизы
0
Аналитика
Безопасность
master
src/net/pccrc.c
816 строк
23 KB
Michael Brown
[peerdist] Fix segment identifier constant on big-endian targets
13 июн 2026, 18:03
13 июн 2026, 18:03
6476f7c
Код
Авторство
О чём код?
/* * Copyright (C) 2015 Michael Brown <mbrown@fensystems.co.uk>. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301, USA. * * You can also choose to distribute this program under the terms of * the Unmodified Binary Distribution Licence (as given in the file * COPYING.UBDL), provided that you have satisfied its requirements. */ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL ); FILE_SECBOOT ( PERMITTED ); #include <errno.h> #include <assert.h> #include <ipxe/sha256.h> #include <ipxe/sha512.h> #include <ipxe/hmac.h> #include <ipxe/base16.h> #include <ipxe/pccrc.h> /** @file * * Peer Content Caching and Retrieval: Content Identification [MS-PCCRC] * */ /****************************************************************************** * * Utility functions * ****************************************************************************** */ /** * Transcribe hash value (for debugging) * * @v info Content information * @v hash Hash value * @ret string Hash value string */ static inline const char * peerdist_info_hash_ntoa ( const struct peerdist_info *info, const void *hash ) { static char buf[ ( 2 * PEERDIST_DIGEST_MAX_SIZE ) + 1 /* NUL */ ]; size_t digestsize = info->digestsize; /* Sanity check */ assert ( info != NULL ); assert ( digestsize != 0 ); assert ( base16_encoded_len ( digestsize ) < sizeof ( buf ) ); /* Transcribe hash value */ base16_encode ( hash, digestsize, buf, sizeof ( buf ) ); return buf; } /** * Get raw data * * @v info Content information * @v data Data buffer * @v offset Starting offset * @v len Length * @ret rc Return status code */ static int peerdist_info_get ( const struct peerdist_info *info, void *data, size_t offset, size_t len ) { /* Sanity check */ if ( ( offset > info->raw.len ) || ( len > ( info->raw.len - offset ) ) ) { DBGC ( info, "PCCRC %p data underrun at [%zx,%zx) of %zx\n", info, offset, ( offset + len ), info->raw.len ); return -ERANGE; } /* Copy data */ memcpy ( data, ( info->raw.data + offset ), len ); return 0; } /** * Populate segment hashes * * @v segment Content information segment to fill in * @v hash Segment hash of data * @v secret Segment secret */ static void peerdist_info_segment_hash ( struct peerdist_info_segment *segment, const void *hash, const void *secret ){ const struct peerdist_info *info = segment->info; struct digest_algorithm *digest = info->digest; uint8_t ctx[ hmac_ctxsize ( digest ) ]; size_t digestsize = info->digestsize; static const uint8_t magic[] = PEERDIST_SEGMENT_ID_MAGIC; /* Sanity check */ assert ( digestsize <= sizeof ( segment->hash ) ); assert ( digestsize <= sizeof ( segment->secret ) ); assert ( digestsize <= sizeof ( segment->id ) ); /* Get segment hash of data */ memcpy ( segment->hash, hash, digestsize ); /* Get segment secret */ memcpy ( segment->secret, secret, digestsize ); /* Calculate segment identifier */ hmac_init ( digest, ctx, segment->secret, digestsize ); hmac_update ( digest, ctx, segment->hash, digestsize ); hmac_update ( digest, ctx, magic, sizeof ( magic ) ); hmac_final ( digest, ctx, segment->id ); } /****************************************************************************** * * Content Information version 1 * ****************************************************************************** */ /** * Get number of blocks within a block description * * @v info Content information * @v offset Block description offset * @ret blocks Number of blocks, or negative error */ static int peerdist_info_v1_blocks ( const struct peerdist_info *info, size_t offset ) { struct peerdist_info_v1_block raw; unsigned int blocks; int rc; /* Get block description header */ if ( ( rc = peerdist_info_get ( info, &raw, offset, sizeof ( raw ) ) ) != 0 ) return rc; /* Calculate number of blocks */ blocks = le32_to_cpu ( raw.blocks ); return blocks; } /** * Locate block description * * @v info Content information * @v index Segment index * @ret offset Block description offset, or negative error */ static ssize_t peerdist_info_v1_block_offset ( const struct peerdist_info *info, unsigned int index ) { size_t digestsize = info->digestsize; unsigned int i; size_t offset; int blocks; int rc; /* Sanity check */ assert ( index < info->segments ); /* Calculate offset of first block description */ offset = ( sizeof ( struct peerdist_info_v1 ) + ( info->segments * sizeof ( peerdist_info_v1_segment_t ( digestsize ) ) ) ); /* Iterate over block descriptions until we find this segment */ for ( i = 0 ; i < index ; i++ ) { /* Get number of blocks */ blocks = peerdist_info_v1_blocks ( info, offset ); if ( blocks < 0 ) { rc = blocks; DBGC ( info, "PCCRC %p segment %d could not get number " "of blocks: %s\n", info, i, strerror ( rc ) ); return rc; } /* Move to next block description */ offset += sizeof ( peerdist_info_v1_block_t ( digestsize, blocks ) ); } return offset; } /** * Populate content information * * @v info Content information to fill in * @ret rc Return status code */ static int peerdist_info_v1 ( struct peerdist_info *info ) { struct peerdist_info_v1 raw; struct peerdist_info_segment first; struct peerdist_info_segment last; size_t first_skip; size_t last_skip; size_t last_read; int rc; /* Get raw header */ if ( ( rc = peerdist_info_get ( info, &raw, 0, sizeof ( raw ) ) ) != 0){ DBGC ( info, "PCCRC %p could not get V1 content information: " "%s\n", info, strerror ( rc ) ); return rc; } assert ( raw.version.raw == cpu_to_le16 ( PEERDIST_INFO_V1 ) ); /* Determine hash algorithm */ switch ( raw.hash ) { case cpu_to_le32 ( PEERDIST_INFO_V1_HASH_SHA256 ) : info->digest = &sha256_algorithm; break; case cpu_to_le32 ( PEERDIST_INFO_V1_HASH_SHA384 ) : info->digest = &sha384_algorithm; break; case cpu_to_le32 ( PEERDIST_INFO_V1_HASH_SHA512 ) : info->digest = &sha512_algorithm; break; default: DBGC ( info, "PCCRC %p unsupported hash algorithm %#08x\n", info, le32_to_cpu ( raw.hash ) ); return -ENOTSUP; } info->digestsize = info->digest->digestsize; assert ( info->digest != NULL ); DBGC2 ( info, "PCCRC %p using %s[%zd]\n", info, info->digest->name, ( info->digestsize * 8 ) ); /* Calculate number of segments */ info->segments = le32_to_cpu ( raw.segments ); /* Get first segment */ if ( ( rc = peerdist_info_segment ( info, &first, 0 ) ) != 0 ) return rc; /* Calculate range start offset */ info->range.start = first.range.start; /* Calculate trimmed range start offset */ first_skip = le32_to_cpu ( raw.first ); info->trim.start = ( first.range.start + first_skip ); /* Get last segment */ if ( ( rc = peerdist_info_segment ( info, &last, ( info->segments - 1 ) ) ) != 0 ) return rc; /* Calculate range end offset */ info->range.end = last.range.end; /* Calculate trimmed range end offset */ if ( raw.last ) { /* Explicit length to include from last segment is given */ last_read = le32_to_cpu ( raw.last ); last_skip = ( last.index ? 0 : first_skip ); info->trim.end = ( last.range.start + last_skip + last_read ); } else { /* No explicit length given: range extends to end of segment */ info->trim.end = last.range.end; } return 0; } /** * Populate content information segment * * @v segment Content information segment to fill in * @ret rc Return status code */ static int peerdist_info_v1_segment ( struct peerdist_info_segment *segment ) { const struct peerdist_info *info = segment->info; size_t digestsize = info->digestsize; peerdist_info_v1_segment_t ( digestsize ) raw; ssize_t raw_offset; int blocks; int rc; /* Sanity checks */ assert ( segment->index < info->segments ); /* Get raw description */ raw_offset = ( sizeof ( struct peerdist_info_v1 ) + ( segment->index * sizeof ( raw ) ) ); if ( ( rc = peerdist_info_get ( info, &raw, raw_offset, sizeof ( raw ) ) ) != 0 ) { DBGC ( info, "PCCRC %p segment %d could not get segment " "description: %s\n", info, segment->index, strerror ( rc ) ); return rc; } /* Calculate start offset of this segment */ segment->range.start = le64_to_cpu ( raw.segment.offset ); /* Calculate end offset of this segment */ segment->range.end = ( segment->range.start + le32_to_cpu ( raw.segment.len ) ); /* Calculate block size of this segment */ segment->blksize = le32_to_cpu ( raw.segment.blksize ); /* Locate block description for this segment */ raw_offset = peerdist_info_v1_block_offset ( info, segment->index ); if ( raw_offset < 0 ) { rc = raw_offset; return rc; } /* Get number of blocks */ blocks = peerdist_info_v1_blocks ( info, raw_offset ); if ( blocks < 0 ) { rc = blocks; DBGC ( info, "PCCRC %p segment %d could not get number of " "blocks: %s\n", info, segment->index, strerror ( rc ) ); return rc; } segment->blocks = blocks; /* Calculate segment hashes */ peerdist_info_segment_hash ( segment, raw.hash, raw.secret ); return 0; } /** * Populate content information block * * @v block Content information block to fill in * @ret rc Return status code */ static int peerdist_info_v1_block ( struct peerdist_info_block *block ) { const struct peerdist_info_segment *segment = block->segment; const struct peerdist_info *info = segment->info; size_t digestsize = info->digestsize; peerdist_info_v1_block_t ( digestsize, segment->blocks ) raw; ssize_t raw_offset; int rc; /* Sanity checks */ assert ( block->index < segment->blocks ); /* Calculate start offset of this block */ block->range.start = ( segment->range.start + ( block->index * segment->blksize ) ); /* Calculate end offset of this block */ block->range.end = ( block->range.start + segment->blksize ); if ( block->range.end > segment->range.end ) block->range.end = segment->range.end; /* Locate block description */ raw_offset = peerdist_info_v1_block_offset ( info, segment->index ); if ( raw_offset < 0 ) { rc = raw_offset; return rc; } /* Get block hash */ raw_offset += offsetof ( typeof ( raw ), hash[block->index] ); if ( ( rc = peerdist_info_get ( info, block->hash, raw_offset, digestsize ) ) != 0 ) { DBGC ( info, "PCCRC %p segment %d block %d could not get " "hash: %s\n", info, segment->index, block->index, strerror ( rc ) ); return rc; } return 0; } /** Content information version 1 operations */ static struct peerdist_info_operations peerdist_info_v1_operations = { .info = peerdist_info_v1, .segment = peerdist_info_v1_segment, .block = peerdist_info_v1_block, }; /****************************************************************************** * * Content Information version 2 * ****************************************************************************** */ /** A segment cursor */ struct peerdist_info_v2_cursor { /** Raw data offset */ size_t offset; /** Number of segments remaining within this chunk */ unsigned int remaining; /** Accumulated segment length */ size_t len; }; /** * Initialise segment cursor * * @v cursor Segment cursor */ static inline void peerdist_info_v2_cursor_init ( struct peerdist_info_v2_cursor *cursor ) { /* Initialise cursor */ cursor->offset = ( sizeof ( struct peerdist_info_v2 ) + sizeof ( struct peerdist_info_v2_chunk ) ); cursor->remaining = 0; cursor->len = 0; } /** * Update segment cursor to next segment description * * @v info Content information * @v offset Current offset * @v remaining Number of segments remaining within this chunk * @ret rc Return status code */ static int peerdist_info_v2_cursor_next ( const struct peerdist_info *info, struct peerdist_info_v2_cursor *cursor ) { size_t digestsize = info->digestsize; peerdist_info_v2_segment_t ( digestsize ) raw; struct peerdist_info_v2_chunk chunk; int rc; /* Get chunk description if applicable */ if ( ! cursor->remaining ) { /* Get chunk description */ if ( ( rc = peerdist_info_get ( info, &chunk, ( cursor->offset - sizeof ( chunk ) ), sizeof ( chunk ) ) ) != 0 ) return rc; /* Update number of segments remaining */ cursor->remaining = ( be32_to_cpu ( chunk.len ) / sizeof ( raw ) ); } /* Get segment description header */ if ( ( rc = peerdist_info_get ( info, &raw.segment, cursor->offset, sizeof ( raw.segment ) ) ) != 0 ) return rc; /* Update cursor */ cursor->offset += sizeof ( raw ); cursor->remaining--; if ( ! cursor->remaining ) cursor->offset += sizeof ( chunk ); cursor->len += be32_to_cpu ( raw.segment.len ); return 0; } /** * Get number of segments and total length * * @v info Content information * @v len Length to fill in * @ret rc Number of segments, or negative error */ static int peerdist_info_v2_segments ( const struct peerdist_info *info, size_t *len ) { struct peerdist_info_v2_cursor cursor; unsigned int segments; int rc; /* Iterate over all segments */ for ( peerdist_info_v2_cursor_init ( &cursor ), segments = 0 ; cursor.offset < info->raw.len ; segments++ ) { /* Update segment cursor */ if ( ( rc = peerdist_info_v2_cursor_next ( info, &cursor ) ) != 0 ) { DBGC ( info, "PCCRC %p segment %d could not update " "segment cursor: %s\n", info, segments, strerror ( rc ) ); return rc; } } /* Record accumulated length */ *len = cursor.len; return segments; } /** * Populate content information * * @v info Content information to fill in * @ret rc Return status code */ static int peerdist_info_v2 ( struct peerdist_info *info ) { struct peerdist_info_v2 raw; size_t len = 0; int segments; int rc; /* Get raw header */ if ( ( rc = peerdist_info_get ( info, &raw, 0, sizeof ( raw ) ) ) != 0){ DBGC ( info, "PCCRC %p could not get V2 content information: " "%s\n", info, strerror ( rc ) ); return rc; } assert ( raw.version.raw == cpu_to_le16 ( PEERDIST_INFO_V2 ) ); /* Determine hash algorithm */ switch ( raw.hash ) { case PEERDIST_INFO_V2_HASH_SHA512_TRUNC : info->digest = &sha512_algorithm; info->digestsize = ( 256 / 8 ); break; default: DBGC ( info, "PCCRC %p unsupported hash algorithm %#02x\n", info, raw.hash ); return -ENOTSUP; } assert ( info->digest != NULL ); DBGC2 ( info, "PCCRC %p using %s[%zd]\n", info, info->digest->name, ( info->digestsize * 8 ) ); /* Calculate number of segments and total length */ segments = peerdist_info_v2_segments ( info, &len ); if ( segments < 0 ) { rc = segments; DBGC ( info, "PCCRC %p could not get segment count and length: " "%s\n", info, strerror ( rc ) ); return rc; } info->segments = segments; /* Calculate range start offset */ info->range.start = be64_to_cpu ( raw.offset ); /* Calculate trimmed range start offset */ info->trim.start = ( info->range.start + be32_to_cpu ( raw.first ) ); /* Calculate range end offset */ info->range.end = ( info->range.start + len ); /* Calculate trimmed range end offset */ info->trim.end = ( raw.len ? be64_to_cpu ( raw.len ) : info->range.end ); return 0; } /** * Populate content information segment * * @v segment Content information segment to fill in * @ret rc Return status code */ static int peerdist_info_v2_segment ( struct peerdist_info_segment *segment ) { const struct peerdist_info *info = segment->info; size_t digestsize = info->digestsize; peerdist_info_v2_segment_t ( digestsize ) raw; struct peerdist_info_v2_cursor cursor; unsigned int index; size_t len; int rc; /* Sanity checks */ assert ( segment->index < info->segments ); /* Iterate over all segments before the target segment */ for ( peerdist_info_v2_cursor_init ( &cursor ), index = 0 ; index < segment->index ; index++ ) { /* Update segment cursor */ if ( ( rc = peerdist_info_v2_cursor_next ( info, &cursor ) ) != 0 ) { DBGC ( info, "PCCRC %p segment %d could not update " "segment cursor: %s\n", info, index, strerror ( rc ) ); return rc; } } /* Get raw description */ if ( ( rc = peerdist_info_get ( info, &raw, cursor.offset, sizeof ( raw ) ) ) != 0 ) { DBGC ( info, "PCCRC %p segment %d could not get segment " "description: %s\n", info, segment->index, strerror ( rc ) ); return rc; } /* Calculate start offset of this segment */ segment->range.start = ( info->range.start + cursor.len ); /* Calculate end offset of this segment */ len = be32_to_cpu ( raw.segment.len ); segment->range.end = ( segment->range.start + len ); /* Model as a segment containing a single block */ segment->blocks = 1; segment->blksize = len; /* Calculate segment hashes */ peerdist_info_segment_hash ( segment, raw.hash, raw.secret ); return 0; } /** * Populate content information block * * @v block Content information block to fill in * @ret rc Return status code */ static int peerdist_info_v2_block ( struct peerdist_info_block *block ) { const struct peerdist_info_segment *segment = block->segment; const struct peerdist_info *info = segment->info; size_t digestsize = info->digestsize; /* Sanity checks */ assert ( block->index < segment->blocks ); /* Model as a block covering the whole segment */ memcpy ( &block->range, &segment->range, sizeof ( block->range ) ); memcpy ( block->hash, segment->hash, digestsize ); return 0; } /** Content information version 2 operations */ static struct peerdist_info_operations peerdist_info_v2_operations = { .block = peerdist_info_v2_block, .segment = peerdist_info_v2_segment, .info = peerdist_info_v2, }; /****************************************************************************** * * Content Information * ****************************************************************************** */ /** * Populate content information * * @v data Raw data * @v len Length of raw data * @v info Content information to fill in * @ret rc Return status code */ int peerdist_info ( const void *data, size_t len, struct peerdist_info *info ) { union peerdist_info_version version; int rc; /* Initialise structure */ memset ( info, 0, sizeof ( *info ) ); info->raw.data = data; info->raw.len = len; /* Get version */ if ( ( rc = peerdist_info_get ( info, &version, 0, sizeof ( version ) ) ) != 0 ) { DBGC ( info, "PCCRC %p could not get version: %s\n", info, strerror ( rc ) ); return rc; } DBGC2 ( info, "PCCRC %p version %d.%d\n", info, version.major, version.minor ); /* Determine version */ switch ( version.raw ) { case cpu_to_le16 ( PEERDIST_INFO_V1 ) : info->op = &peerdist_info_v1_operations; break; case cpu_to_le16 ( PEERDIST_INFO_V2 ) : info->op = &peerdist_info_v2_operations; break; default: DBGC ( info, "PCCRC %p unsupported version %d.%d\n", info, version.major, version.minor ); return -ENOTSUP; } assert ( info->op != NULL ); assert ( info->op->info != NULL ); /* Populate content information */ if ( ( rc = info->op->info ( info ) ) != 0 ) return rc; DBGC2 ( info, "PCCRC %p range [%08zx,%08zx) covers [%08zx,%08zx) with " "%d segments\n", info, info->range.start, info->range.end, info->trim.start, info->trim.end, info->segments ); return 0; } /** * Populate content information segment * * @v info Content information * @v segment Content information segment to fill in * @v index Segment index * @ret rc Return status code */ int peerdist_info_segment ( const struct peerdist_info *info, struct peerdist_info_segment *segment, unsigned int index ) { int rc; /* Sanity checks */ assert ( info != NULL ); assert ( info->op != NULL ); assert ( info->op->segment != NULL ); if ( index >= info->segments ) { DBGC ( info, "PCCRC %p segment %d of [0,%d) out of range\n", info, index, info->segments ); return -ERANGE; } /* Initialise structure */ memset ( segment, 0, sizeof ( *segment ) ); segment->info = info; segment->index = index; /* Populate content information segment */ if ( ( rc = info->op->segment ( segment ) ) != 0 ) return rc; DBGC2 ( info, "PCCRC %p segment %d range [%08zx,%08zx) with %d " "blocks\n", info, segment->index, segment->range.start, segment->range.end, segment->blocks ); DBGC2 ( info, "PCCRC %p segment %d digest %s\n", info, segment->index, peerdist_info_hash_ntoa ( info, segment->hash ) ); DBGC2 ( info, "PCCRC %p segment %d secret %s\n", info, segment->index, peerdist_info_hash_ntoa ( info, segment->secret ) ); DBGC2 ( info, "PCCRC %p segment %d identf %s\n", info, segment->index, peerdist_info_hash_ntoa ( info, segment->id ) ); return 0; } /** * Populate content information block * * @v segment Content information segment * @v block Content information block to fill in * @v index Block index * @ret rc Return status code */ int peerdist_info_block ( const struct peerdist_info_segment *segment, struct peerdist_info_block *block, unsigned int index ) { const struct peerdist_info *info = segment->info; size_t start; size_t end; int rc; /* Sanity checks */ assert ( segment != NULL ); assert ( info != NULL ); assert ( info->op != NULL ); assert ( info->op->block != NULL ); if ( index >= segment->blocks ) { DBGC ( info, "PCCRC %p segment %d block %d of [0,%d) out of " "range\n", info, segment->index, index, segment->blocks); return -ERANGE; } /* Initialise structure */ memset ( block, 0, sizeof ( *block ) ); block->segment = segment; block->index = index; /* Populate content information block */ if ( ( rc = info->op->block ( block ) ) != 0 ) return rc; /* Calculate trimmed range */ start = block->range.start; if ( start < info->trim.start ) start = info->trim.start; end = block->range.end; if ( end > info->trim.end ) end = info->trim.end; if ( end < start ) end = start; block->trim.start = start; block->trim.end = end; DBGC2 ( info, "PCCRC %p segment %d block %d hash %s\n", info, segment->index, block->index, peerdist_info_hash_ntoa ( info, block->hash ) ); DBGC2 ( info, "PCCRC %p segment %d block %d range [%08zx,%08zx) covers " "[%08zx,%08zx)\n", info, segment->index, block->index, block->range.start, block->range.end, block->trim.start, block->trim.end ); return 0; }