# Patent

## Title
Secure collection synchronization using matched network names

## Abstract

One embodiment provides a system that facilitates facilitate secure synchronization of manifests using exact network names. During operation, the system generates an interest of advertisement comprising a name of a content object of the system. This name represents a collection of objects of the system and includes a first hash that is based on a key of the system. The first hash corresponds to a respective content object hash of one or more segments of a manifest representing the collection of objects. The system also determines a request for the content object based on the name in an interest of data from a remote node.

## Background
BACKGROUND
1. Field
This disclosure is generally related to data security. More specifically, this disclosure is related to secure synchronization of collections in a network using exact match names.
2. Related Art
In many computing applications, it is often important for peers on a network to synchronize their respective collections of data. The proliferation of digital content creates a vast number of collections which require reconciliation. Content-Centric Network (CCN) architectures have been designed to facilitate accessing and processing such digital content. A CCN includes entities, or nodes, such as network clients, forwarders (e.g., routers), and content producers, which communicate with each other by sending “interest” packets for various content items and receiving “content object” packets in return. CCN interests and content objects are identified based on a unique name, which is typically a hierarchically structured variable length identifier (HSVLI) comprising contiguous name components ordered from a most general level to a most specific level.
In many computing applications, it is often important for devices in a network to express interests for their respective collections of data. The proliferation of digital content creates a vast number of collections which require reconciliation. CCN architectures have been designed to facilitate accessing such digital content. These networks include entities, or nodes, such as network clients, forwarders (e.g., routers and switches), and content producers, which communicate with each other by sending “interest” packets for various content items and receiving “response” packets comprising content objects in return. Unlike a traditional Internet Protocol (IP) network, where an object is tied to its location and its IP address, the content objects in a CCN are identified based on a specific name, which is location-independent and typically is an HSVLI.
For example, a border router that is connected to multiple areas of a computer network can subscribe to namespaces for those areas (e.g., “Area 1” and “Area 2”). Other routers that are not border routers may only subscribe to a single area. This way, a router that subscribes to the namespace “Area 1” only obtains network-configuration items for Area 1, and a router that subscribes to the namespace “Area 2” only obtains network-configuration items for Area 2. The border router that subscribes to both namespaces can obtain network-configuration items for Area 1 and Area 2.
Because a network-configuration item's structured name is unique and persistent, a node in a CCN can generate a hash value for each network-configuration item based on the structured name, without having to process the data for each content item. The node can also generate an additive hash for each routing-data collection, based on the hashes for the individual network-configuration items of a routing-data collection, so that the additive hash represents the contents of the routing-data collection. For example, the node can generate the additive hash by using an addition operation (or some other mathematical function) to process the hashes for the individual network-configuration items of the routing-data collection.
A typical CCN synchronization protocol uses a longest-prefix match method, where an interest in “/parc/events/” matches both “/parc/events/calendar.txt” and “/parc/events/conference.txt.” As CCN architectures evolve, the synchronization protocol also evolves to allow the use of exact name match, rather than the current longest-prefix match. During synchronization, a node hosting a collection advertises the collection using its name. Any other node needing to synchronize the collection sends a request with the exact name and receives a response back comprising the collection. However, an adverse node can send a malicious advertisement. As a result, the node receiving the advertisement needs assurance that the advertisement is a valid one. Though CCN brings many desirable features to a network, some issues remain unsolved for secure synchronization of collections.
SUMMARY
One embodiment provides a system that facilitates secure synchronization of manifests using exact network names. During operation, the system generates an interest of advertisement comprising a name of a content object of the system. This name represents a collection of objects of the system and includes a first hash that is based on a key of the system. The first hash corresponds to a respective content object hash of one or more segments of a manifest representing the collection of objects. The system also determines a request for the content object based on the name in an interest of data from a remote node.
In a variation on this embodiment, the content object is a first segment of the manifest and comprises a second hash of a second segment of the manifest.
In a further variation, the system elects the manifest in the system for the interest of advertisement from a plurality of manifests with a same manifest hash. The plurality of manifests is distributed among a plurality of nodes.
In a variation on this embodiment, the content object is a secure catalog in the system. This secure catalog comprises the respective content object hash of the segments of the manifest; and the first hash is a hash of the secure catalog.
In a further variation, the system signs the secure catalog using the key of the system.
In a further variation, the system elects the secure catalog at the system for the interest of advertisement from a plurality of secure catalogs with a same content object hash. The plurality of secure catalogs is distributed among a plurality of nodes.
In a further variation, the secure catalog is distributed among a plurality of segments. A content object of a first segment of the secure catalog includes a hash of a content object of a second segment of the secure catalog.
In a variation on this embodiment, the system generates a message comprising a segment of the manifest in response to an interest of data from a remote node for the segment. The interest of data includes one of the content object hashes in the secure catalog.
In a variation on this embodiment, the key of the computing device identifies the computing device as a trusted publisher.
One embodiment provides a system that facilitates multi-object interest using network names. During operation, the system obtains a name of a content object of a remote node from an interest of advertisement. The name represents a collection of objects at the remote node and includes a first hash that is based on a key of the remote node. The first hash corresponds to a respective content object hash of one or more segments of a manifest representing the collection of objects. The system further generates for the remote node an interest of data comprising a request for the content object based on the name.



BRIEF DESCRIPTION OF THE FIGURES
FIG. 1 illustrates an exemplary computer system that facilitates synchronization of manifests among nodes in a Content-Centric Network (CCN), in accordance with an embodiment of the present invention.
FIG. 2 illustrates exemplary communication between a local node and a remote node, in accordance with an embodiment of the present invention.
FIG. 3 presents a flowchart illustrating the process of synchronizing content associated with a remote manifest and a local manifest, in accordance with an embodiment of the present invention.
FIG. 4 presents a flowchart illustrating the process of synchronizing content associated with a remote manifest and a local manifest based on a modified time, in accordance with an embodiment of the present invention
FIG. 5 presents a flowchart illustrating the process of transmitting an advertisement corresponding to a manifest, in accordance with an embodiment of the present invention.
FIG. 6A presents a table depicting the format of a manifest and the content objects represented in the collection, in accordance with an embodiment of the present invention.
FIG. 6B presents tables depicting the format of two manifests during synchronization, where the local manifest is missing a content object from the remote manifest, in accordance with an embodiment of the present invention.
FIG. 6C presents tables depicting the format of two manifests during synchronization, where the digest of a same named content object in the local manifest is different from the digest in the remote manifest, and where the remote node advertises its manifest, in accordance with an embodiment of the present invention.
FIG. 6D presents tables depicting the format of two manifests during synchronization, where the digest of a same named content object in the local manifest is different from the digest in the remote manifest, and where the local node advertises its manifest, in accordance with an embodiment of the present invention.
FIG. 6E presents tables depicting the format of two manifests during synchronization, when the digest and modified time of a same named content object in the local manifest is different from the digest in the remote manifest, in accordance with an embodiment of the present invention.
FIG. 7A illustrates an exemplary secure synchronization of manifests, in accordance with an embodiment of the present invention.
FIG. 7B illustrates an exemplary hash chain for secure synchronization of manifests, in accordance with an embodiment of the present invention.
FIG. 8A presents a flowchart illustrating the process of a node securely synchronizing a local manifest using a hash chain, in accordance with an embodiment of the present invention.
FIG. 8B presents a flowchart illustrating the process of a node initiating a secure synchronization of a remote manifest using a hash chain, in accordance with an embodiment of the present invention.
FIG. 8C presents a flowchart illustrating the process of a node securely synchronizing a remote manifest using a hash chain, in accordance with an embodiment of the present invention.
FIG. 9A illustrates an exemplary secure catalog for secure synchronization of manifests, in accordance with an embodiment of the present invention.
FIG. 9B illustrates an exemplary secure synchronization of manifests using a secure catalog, in accordance with an embodiment of the present invention.
FIG. 10A presents a flowchart illustrating the process of a node securely synchronizing a local manifest using a secure catalog, in accordance with an embodiment of the present invention.
FIG. 10B presents a flowchart illustrating the process of a node securely synchronizing a remote manifest using a secure catalog, in accordance with an embodiment of the present invention.
FIG. 11 illustrates an exemplary computer and communication system that facilitates secure synchronization of manifests in a CCN, in accordance with an embodiment of the present invention.



In the figures, like reference numerals refer to the same figure elements.
DETAILED DESCRIPTION
The following description is presented to enable any person skilled in the art to make and use the embodiments, and is provided in the context of a particular application and its requirements. Various modifications to the disclosed embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the present disclosure. Thus, the present invention is not limited to the embodiments shown, but is to be accorded the widest scope consistent with the principles and features disclosed herein.
Overview
In embodiments of the present invention, the problem of securely synchronizing a collection of objects using exact matched name is solved by incorporating a cryptographic hash with the interest for the collection of objects within the Content-Centric Network (CCN) namespace. In this disclosure, the terms “content object” and “object” are used interchangeably. With existing technologies, in a CCN, a host node can notify regarding a content object (i.e., a new content item), or an object, at any time by broadcasting an interest packet comprising the persistent name of the object. This interest packet can be referred to as an interest. Dissemination of interests allows other nodes to be aware of the object. In response to receiving an interest of advertisement, an interested node sends an interest of data to obtain the desired object. In response, the host node can send a response packet comprising the object. This response packet can be referred to as a response. In this disclosure, the terms “interest packet” and “interest” are used interchangeably. The terms “response packet” and “response” are also used interchangeably.
An interest of advertisement is an interest used for advertising a content object in a CCN. A node can send an interest of advertisement upon obtaining or updating a content object. On the other hand, an interest of data is an interest used for requesting a content object (i.e., data) in a CCN. A node can send an interest of data to express an interest (or request) for any content object.
In either interest, a name in the CCN namespace (e.g., a hierarchically structured variable length identifier (HSVLI)) is used to identify the content object. In some embodiments, the name includes an identification of the relevant namespace (or a namespace identification). This namespace identification is part of a CCN name which distinguishes between the interests. For example, the name can include “/adv” for advertisements and “/data” for data.
For a large collection of objects, sending a respective interest for a respective object leads to inefficient, bandwidth-intensive, and repetitive dissemination of interests. CCN can be extended to incorporate Manifest-Based Content Networking (MBCN). A content consumer node in a CCN can express an interest for a collection of objects using a manifest name representing the collection. In some embodiments, the manifest is an ordered list of objects in the collection. The manifest can include the respective names of the objects and their corresponding hash. By sending an interest of advertisement, which can also be referred to as an advertisement, for a manifest, a host node can make remote nodes aware of the collection. However, the host node can be malicious and send an adverse interest of advertisement.
To solve this problem, embodiments of the present invention incorporate a cryptographic hash with such an interest of advertisement. For example, this hash can be the part of the name of the manifest in the interest. In some embodiments, this secure synchronization with exact match names can be obtained using a hash chain. If the manifest is large and requires segmentation for dissemination, the interest of advertisement can include the hash of the first segment of the manifest. A respective segment, except the last one, can contain the hash of one or more subsequent segments in a designated field, thereby forming a hash chain. As a result, upon obtaining each segment, a node becomes aware of the hash of the next segment. In some embodiments, this secure synchronization with exact match names can be obtained using a secure catalog. The interest of advertisement can contain the hash of the secure catalog (or the first segment of the secure catalog). The secure catalog contains the hash of a respective segment of the manifest. By receiving the catalog, a node can obtain the respective hash of a respective manifest segment and send an interest for that segment using the corresponding hash.
Embodiments of the present invention provide a system which facilitates synchronization of manifests among nodes on a network by using exact match names. In the following description of embodiments of the present invention, the relevant CCN entities are a local node and a remote node, although the roles can be reversed. Each of the local and remote nodes is associated with a manifest, which represents a collection of content objects at a node. A manifest is identified by a specific prefix, such that two manifests with the same prefix correspond to the same collection of content objects.
In some embodiments, the manifest is an ordered list identifying a collection of content objects. Each content object in a collection is identified by its name and corresponding digest, where the digest is the hash value of the content object. In some embodiments, each content object is also identified by a modified time, which indicates the time that the content was modified. For the purposes of this description, the manifest is described as an ordered list, but other embodiments include the manifest structured as a synchronization tree, which contains content objects as well as nested collections of content objects. The system generates a root hash value for the manifest. The root hash value is an additive hash value based on the hash values of the individual content objects of the collection. The root hash value of the manifest is a unique identifier for the manifest.
The system can synchronize the collections in a local manifest with the contents in a local manifest using exact match names. A remote node advertises a hash of its manifest. A local node receives the advertisement and determines that the advertised remote manifest corresponds to a local manifest, where the remote manifest and the local manifest correspond to the same collection of content objects. The local node determines whether the contents of the local manifest are synchronized with the contents of the remote manifest by comparing the root hash value of the local manifest with the root hash value of the remote manifest. If they do not match, then the local node retrieves the remote manifest by sending a request for the remote manifest to the remote node.
In some embodiments, the local node sends a set of interests based on a segmentation protocol, and each interest corresponds to a numbered segment of the manifest. In some embodiments, the remote node can advertise the number of segments corresponding to its manifest. The local node, in possession of the remote manifest, determines which content objects indicated in the remote manifest are different from the content objects indicated in the local manifest. Subsequently, the local node transmits a set of interests for the content objects that are different, where the interest includes the name of the requested content object. In some embodiments, the interest also includes the corresponding hash value of the requested content object. In this manner, the system uses an exact name match to request and receive the set of different content objects.
In some embodiments, the manifest is transmitted using a structured technique, such as the rolling hash technique in the rsync protocol, rather than sending the complete manifest. The rsync protocol allows efficient transmission of the manifest between two nodes because the nodes already have a similar, but not identical, version of the same manifest.
In some embodiments, a content object in a collection is further identified by a corresponding modified time, which indicates the time the content object was modified. For each content object that is determined to be different, the local node determines whether the modified time of the content object in the remote manifest is more or less recent than the corresponding content object in the local manifest. If the remote content object corresponds to a modified time that is more recent, then the local node updates the value of the content object in the local manifest with the value of the content object from the remote manifest. A description of how to remove, or “white-out,” a content item from a data collection is contained in U.S. patent application Ser. No. 13/681,306, titled “Data Transport by Named Content Synchronization,” by inventors Van L. Jacobson and Marc E. Mosko, filed 19 Nov. 2012, the disclosure of which is incorporated by reference herein.
In some embodiments, if the remote content object corresponds to a modified time that is less recent, the system can determine whether to retain the history by inserting the value of the content object from the remote manifest in a history field of the corresponding content object in the local manifest. The system updates the values accordingly for each content object that is determined to be different. In this manner, the system synchronizes the manifest at a local node with the manifest at a remote node.
In some embodiments, the network clients, network nodes (e.g., forwarders such as routers), and publishers communicate over an information-centric network (ICN). In ICN, each piece of content is individually named, and each piece of data is bound to a unique name that distinguishes the data from any other piece of data, such as other versions of the same data or data from other sources. This unique name allows a network device to request the data by disseminating a request or an interest that indicates the unique name, and can obtain the data independently of the data's storage location, network location, application, and means of transportation. Named Data Networks (NDNs) or CCNs are examples of ICN architecture; the following terms describe elements of an NDN or CCN architecture:
Content Object: A single piece of named data, which is bound to a unique name. Content Objects are “persistent,” which means that a Content Object can move around within a computing device, or across different computing devices, but does not change. If any component of the Content Object changes, the entity that made the change creates a new Content Object that includes the updated content, and binds the new Content Object to a new unique name.
Unique Names: A name in an ICN is typically location-independent and uniquely identifies a Content Object. A data-forwarding device can use the name or name prefix to forward a packet toward a network node that generates or stores the Content Object, regardless of a network address or physical location for the Content Object. In some embodiments, the name may be a hierarchically structured variable-length identifier (HSVLI). The HSVLI can be divided into several hierarchical components, which can be structured in various ways. For example, the individual name components parc, home, ndn, and test.txt can be structured in a left-oriented prefix-major fashion to form the name “/parc/home/ndn/test.txt.” Thus, the name “/parc/home/ndn” can be a “parent” or “prefix” of “/parc/home/ndn/test.txt.” Additional components can be used to distinguish between different versions of the content item, such as a collaborative document.
In some embodiments, the name can include a non-hierarchical identifier, such as a hash value that is derived from the Content Object's data (e.g., a checksum value) and/or from elements of the Content Object's name. A description of a hash-based name is described in U.S. patent application Ser. No. 13/847,814 (entitled “ORDERED-ELEMENT NAMING FOR NAME-BASED PACKET FORWARDING,” by inventor Ignacio Solis, filed 20 Mar. 2013), which is hereby incorporated herein by reference. A name can also be a flat label. Hereinafter, “name” is used to refer to any name of a piece of data in a name-data network, such as a hierarchical name or name prefix, a flat name, a fixed-length name, an arbitrary-length name, or a label (e.g., a Multiprotocol Label Switching (MPLS) label).
Interest: A packet that indicates a request for a piece of data, and includes a name (or a name prefix) of the piece of data. A data consumer can disseminate a request or Interest across an information-centric network, which CCN/NDN routers can propagate toward a storage device (e.g., a cache server) or a data producer that can provide the requested data to satisfy the request or Interest.
In some embodiments, the ICN system can include a CCN architecture. However, the methods disclosed herein are also applicable to other ICN architectures as well. A description of a CCN architecture is described in U.S. patent application Ser. No. 12/338,175 (entitled “CONTROLLING THE SPREAD OF INTERESTS AND CONTENT IN A CONTENT CENTRIC NETWORK,” by inventors Van L. Jacobson and Diana K. Smetters, filed 18 Dec. 2008), which is hereby incorporated herein by reference.
In this disclosure, the description in conjunction with FIGS. 1-6 is associated with the general architecture of synchronization of a collection of objects using a manifest; and the description in conjunction with FIG. 7 and onward provides more details on the mechanism for facilitating a secure synchronization of the collection objects.
Exemplary Network and Manifest
FIG. 1 illustrates an exemplary computer system that facilitates synchronization of manifests among nodes in a CCN, in accordance with an embodiment of the present invention. In the example in FIG. 1, network 100 facilitates synchronization of manifests among nodes in a CCN. Network 100 can include a client device 116 (or consumer 116), a content producing device 118 (or producer 118), and a router or other forwarder at nodes 102, 104, 106, 108, 110, 112, and 114. Nodes 102-114 can each contain one or more manifests. For example, node 112 contains a manifest 120. Manifest 120 comprises a collection name 122 and an ordered list of content objects identified by one or more of the following: a content object name 130.1-130.n; a digest 132.1-132.n, and a modified time 134.1-134.n. The digests 132.1-132.n comprise a hash value of the content object identified respectively by names 130.1-130.n. In some embodiments, a digest can be an SHA-256 hash of the content object, where the likelihood of a hash collision (where the one-way hash of two different content objects results in the same value) is sufficiently low such that the digest is a unique identifier for the content object. Manifest 120 also includes a root hash 124, which is an additive hash value based on the digests (i.e., hash values) 132.1-132.n of the individual content objects of the collection. Root hash 124 is a unique identifier for manifest 120 and represents the content objects in the collection.
In some embodiments, a manifest indicates a name and a corresponding digest, but does not indicate a modified time. Such a system can include, e.g., a file server where prior versions of a text file are important and thus retained by the system. In other embodiments, a manifest indicates a name, a corresponding digest, and a modified time. The system can use the modified time to determine which version of the content item should be retained. For example, if the content items indicate a link state, then the system does not need information relating to previous versions. In this case, only the content object with the most recent modified time is retained.
Any two nodes in a network can contain a manifest that represents the same collection of data, where the manifests can be synchronized using the methods described herein. The terms “local node” and “remote node” can apply to any node in a content-centric network (CCN) and are used in this disclosure to differentiate between two nodes in a CCN.
Structure of Names
Synchronization of manifests representing the same collection of data between two nodes is based on a three-part name. The first part is a routable prefix that identifies the collection, such as “/a/b.” The second part contains an identification of the relevant namespace (or a namespace identification), and can be “/adv” for advertisements or “/data” for data transfers. The third part is the hash value or content being advertised or transferred. Thus, a CCN name is of the form:

    
    
        /collection_prefix/adv_or_data/protocol_data

An example of an interest sending a hash advertisement is:

        /a/b/adv/<roothash>

A local node receiving this advertisement and containing a local manifest with the same routable prefix “/a/b” retrieves the advertised manifest in segments 0, 1, . . . up to the ending segment number m based on a segmentation protocol. Such an interest looks like:

        /a/b/data/<roothash>/<segment number>

Based on the entries in the retrieved manifest, the system determines which content objects identified in the retrieved manifest are different from the content objects identified in the local manifest. The system retrieves the different content objects based on the name of the content object:

        /a/b/data/<name of content object>

In some embodiments, the system retrieves the different content objects based on the hash value of the requested content object:

        /a/b/data/<hash(content object)>

In some embodiments, the system retrieves the different content objects based on the name in the manifest. This technique allows the system to retrieve any cached copy of the object rather than using the name of the content under the collection's namespace. For example, to retrieve the first item from manifest 140 in FIG. 6B, the system sends an Interest for the name and digest:

        /chef/events/calendar.txt, digest={1}

Communication and Synchronization of Manifests Between Two Nodes

    
    


FIG. 2 illustrates exemplary communication between a local node and a remote node, in accordance with an embodiment of the present invention. A communication 200 between node 102 (remote node) and node 106 (local node) facilitates synchronization of a collection of objects based on a manifest. Nodes 102 and 106 each contain a manifest with the same routing prefix 202, or collection name, “/a/b.” Remote node 102 transmits a send_advertisement interest 220 (i.e., an interest of advertisement), which is a hash advertisement containing the root hash value of its manifest identified by collection name “/a/b.” The interest takes the form of: “/a/b/adv/<roothash>.” Local node 106 receives the advertised interest and performs a check_advertised_collection procedure 222 to determine whether node 106 contains a manifest indicating a same collection as the advertised manifest, based on the same collection prefix 202 (“/a/b”). Then, local node 106 determines whether the root hash of its local manifest is different from the root hash of the remote manifest. Differing hash values indicate that the collections need to be synchronized with each other. Local node 106 then performs a retrieve_manifest procedure 224, by sending a set of interests for the manifest. The set of interests is segmented based on a segmentation protocol. The interests are sent in a request_remote_manifest_in_segments interest 226 (i.e., an interest of data), and are of the form: “/a/b/datakroothash>/S0,” “/a/b/datakroothash>/S1,” “/a/b/datakroothash>/S2,” etc. In some embodiments, the advertising node can include the number of segments required to transfer its manifest. In a send_remote_manifest_in_segments message 228, remote node 102 sends the requested manifest back in response to the set of interests. The requested content objects take the form: “/a/b/datakroothash>/S0+payload” where the payload contains the requested segment of the manifest.
Local node 106, in possession of the remote manifest, performs a determine_set_difference procedure 230. In some embodiments, the result of this procedure is a list of content objects identified by name. In other embodiments, the result is a list of content objects identified by their corresponding digest. Local node 106 then transmits a request_set_difference interest 234 for each content object that is determined to be different. The interest takes the form, e.g.: “/a/b/data/name 130.3”. Local node 106 receives the requested content object when remote node 102 transmits a send_set_difference content object 236, where the requested content object takes the form: “/a/b/data/name 130.3+payload.” Thus, local node 106 performs resolve_set_difference procedure 232 by requesting and receiving the content objects determined to be different such that the contents of the local manifest are synchronized with the contents of the remote manifest. In some embodiments, local node 106 performs a sync_based_on_mod_time procedure 240, which is described below in relation to FIG. 4.
FIG. 3 presents a flowchart illustrating the process of synchronizing content associated with a remote manifest and a local manifest, in accordance with an embodiment of the present invention. In the example in FIG. 2, node 106 can be a local node and node 102 can be the remote node. During operation, a local node receives an interest of advertisement corresponding to a remote manifest at a remote node (operation 302). A manifest represents a collection of content objects at a node. The local node determines that the remote manifest and the local manifest indicate the same collection of content objects (operation 304, corresponding to check_advertised_collection procedure 222 in FIG. 2).
In some embodiments, the local node determines if the manifest indicates the same collection by comparing the collection name, or routing prefix, of the manifests. The local node then determines whether the root hash value of its local manifest is different from the root hash value of the remote manifest (operation 306). The root hash value of a manifest is a unique identifier for the manifest, and comprises an additive hash value of the digests of the content objects represented in the manifest. If the root hash value of the local manifest is not the same as the root hash value of the remote manifest (operation 308), the local and remote manifests, which represent the same collection, are not synchronized and need to be reconciled. The local node downloads or transfers the remote manifest by sending a request for, and receiving in response to the request, the remote manifest (operation 310, corresponding to retrieve_manifest procedure 224 in FIG. 2).
The local node determines which content objects identified in the remote manifest are different from the content objects identified in the local manifest (operation 312, corresponding to the determine_set_difference procedure 230 in FIG. 2). In some embodiments, the local node determines the set difference by comparing the digests of the content objects identified in the local manifest with the digests of the same named content objects identified in the remote manifest. If the local node determines a difference, the local node transmits a set of interests of data corresponding to the determined different set of content objects (operation 314), and receives the requested content objects in return (operation 316). This corresponds to the resolve_set_difference procedure 232 shown in FIG. 2. Thus, the contents of the local manifest are synchronized with the contents of the remote manifest.
If the local node has changes, the local node advertises the new root hash value. It can do so immediately, or schedule a next advertisement based on network or other timing considerations. For example, the local node can advertise its root hash at least once per second, but no more than four times a second. Therefore, during reconciliation, as the root hash changes due to updates, the node can advertise up to four changes per second. Otherwise, in a steady state, the node can advertise once per second.
Synchronization Based on Modified Time
FIG. 4 presents a flowchart illustrating the process of synchronizing content associated with a remote manifest and a local manifest based on a modified time, in accordance with an embodiment of the present invention. Note that the synchronization of content can also be based on a sequence number associated with a content object, where a greater sequence number indicates a more recent version of the content object. Synchronization of content can also be based on an ordering of the names of the content objects, where an implicit sort order indicates a more recent version of the content object. This process is represented as sync_based_on_mod_time procedure 240 in FIG. 2. Based on the previously determined set difference, a local node receives a requested set of content objects that include a modified time indicating a time that a corresponding content object was modified (operation 402). For each content object, the local node determines whether the modified time of the content object in the remote manifest is more recent or less recent than the corresponding content object in the local manifest (operation 404). If the modified time of the content object from the remote manifest is more recent (operation 406), then the system updates the value of the content object in the local manifest with the value of the content object from the remote manifest (operation 408). In some embodiments, the local node can determine whether to retain the value of its (less recent) content object in the local manifest by inserting a corresponding value and modified time of the (less recent) content object into a history field in the local manifest before updating the value of the content object in the local manifest. If there are more content objects in the set that need to be retrieved (operation 410), then the system returns to operation 404. If not, then the system has finished retrieving the necessary content objects.
If the modified time of the content object from the remote manifest is less recent than the corresponding content object in the local manifest (operation 406), then the system determines whether to save the value of the (less recent) content object from the remote manifest (operation 412) by inserting a corresponding value and modified time of the (less recent) content object into a history field in the local manifest (operation 414). If there are more content objects in the set that need to be retrieved (operation 410), then the system returns to operation 404. If not, then the system has finished retrieving the necessary content objects. Thus, all content objects determined to be different have been updated, and possibly retained or saved in a history field of the local manifest, such that the contents of the local manifest are synchronized with the contents of the remote manifest.
Transmitting Advertisement, Manifest, and Contents for Synchronization
FIG. 5 presents a flowchart illustrating the process of transmitting an advertisement corresponding to a manifest, in accordance with an embodiment of the present invention. The node in FIG. 5 is described as a local node because it transmits packets to a remote node. Note that the local node in FIG. 5 corresponds to node 102 in FIG. 2, which has been previously referred to as remote node 102. It should be noted that any node in a CCN can be referred to as a remote node or a local node.
A local node transmits an interest of advertisement corresponding to a manifest, where the manifest represents a collection of content objects at a node (operation 502, corresponding to send_advertisement message 220 in FIG. 2). This advertisement is an interest that is akin to a beacon and, based on the “/add” namespace identification used, does not request any content in return. Upon receiving an interest of data from a remote node requesting the manifest, the local node transmits the manifest to the remote node (operation 504, corresponding to receiving request_remote_manifest_in_segments interest 226 and send_remote_manifest_in_segments message 228 in FIG. 2). Upon receiving a request from a remote node for a content object identified in the local manifest, the local node transmits the requested content object to the requesting remote node (operation 506, corresponding to receiving request_set_difference interest 234 and send_set_difference message 236 in FIG. 2).
Manifest Contents During Synchronization
FIG. 6A presents a table depicting the format of a manifest and the content objects represented in the collection, in accordance with an embodiment of the present invention. Manifest 120 comprises an ordered list of content objects identified by a collection name 122 and one or more of the following: a content object name 130.1-130.n; a digest 132.1-132.n; and a modified time 134.1-134.n. The digests 132.1-132.n comprise a hash value of the content object identified respectively by names 130.1-130.n. Manifest 120 also includes a root hash 124, which is an additive hash value based on the hash values 132.1-132.n of the individual content objects of the collection. Root hash 124 of manifest 120 is a unique identifier for manifest 120.
As described in relation to FIG. 1, manifest 120 can indicate a name and corresponding digest for each content object represented in the collection. In some embodiments, manifest 120 can also include a modified time for each content object represented in the collection. The use of the modified time field depends on the underlying application or service being performed. Note that manifest 120 indicates collection name 122. The manifests depicted in FIGS. 6B-E also include a collection name, but because the exemplary manifests comprise the same collections of data, the collection name is not included in FIGS. 6B-6E.
FIGS. 6B-6E depict two nodes, nodes 102 and 106, each of which contains a manifest. In this example, node 102 is the remote node and node 106 is the local node. Local node 106 contains a manifest 160, and remote node 102 contains a manifest 140. Manifests 140 and 160 contain the same collection name, or routing prefix, and thus represent the same collection of content objects or data. Time is indicated by the labels T1, T2, etc., and the contents of manifests 140 and 160 are depicted in relation to these time labels.
Recall that a manifest is further identified by a root hash value, illustrated as root hash 124 in FIG. 6A, which is an additive hash value based on the digests of the individual content objects of the collection. In the following examples, the root hash value and the digests are indicated as a number in brackets, e.g., “{999}”, although the number can be much larger than this. In addition, both the digests of the content objects and the exemplar root hash values of manifests 140 and 160 that change over time are depicted only as sample representations of additive hash values.
Local Manifest Missing a Content Object from Remote Manifest
FIG. 6B presents tables depicting the format of two manifests during synchronization, where the local manifest is missing a content object from the remote manifest, in accordance with an embodiment of the present invention. At time T1, local node 106 receives a hash advertisement from remote node 102 of manifest 140, with a root hash of {999}. Local node 106 determines that its manifest 160 represents the same collection of data as remote manifest 140 and retrieves manifest 140. Local node 106 determines that local manifest 160, with a root hash of {60}, is not synchronized with remote manifest 140, which has a root hash of {999}. Local node 106 then determines the set difference between its local manifest 160 and remote manifest 140. In this example, manifest 160 is missing the content object identified by the name of “/fruit/lychee/peel,” so local node 106 sends an interest to remote node 102 for the content object by that name. Remote node 102 returns the requested content object. At time T2, local node 106 updates its manifest 160 with the missing content object. Based on the contents of manifest 160 at time T2, the system generates a new root hash for manifest 160, which now equals the root hash of the remote manifest. This is depicted by the root hash value of manifest 160 at time T2: {60}→{999}. Thus, the local manifest and the remote manifest have synchronized their collections and both contain the same root hash value of {999}.
Local and Remote Manifests Contain Content Object with Same Name, but Different Digest: Local Node Retrieves Manifest First
FIG. 6C presents tables depicting the format of two manifests during synchronization, where the digest of a same named content object in the local manifest is different from the digest in the remote manifest, and where the remote node advertises its manifest, in accordance with an embodiment of the present invention. At time T3, local node 106 receives a hash advertisement from remote node 102 of manifest 140, with a root hash of {999}. Local node 106 determines that its manifest 160 represents the same collection of data as remote manifest 140 and retrieves manifest 140. Local node 106 determines that local manifest 160, with a root hash of {53}, is not synchronized with remote manifest 140, which has a root hash of {999}. Local node 106 then determines the set difference between its local manifest 160 and remote manifest 140. In this example, manifest 160 is missing the content object identified by the name of “/fruit/lychee/peel” with a digest of {279}, so local node 106 sends an interest to remote node 102 for the content object based on that name and digest. Remote node 102 returns the requested content object. At time T4.a, local node 106 updates its manifest 160 with the missing content object. Based on the contents of manifest 160 at time T4.a, the system generates a new root hash for manifest 160. This is depicted by the root hash value of manifest 160 at time T4.a: {53} {772}. However, manifest 140, with its original root hash of {999}, is now out of sync with manifest 160, which has the new root hash of {772}.
Subsequently, remote node 102 receives a hash advertisement from local node 106 of manifest 160, with the new root hash of {772}. Remote node 102 determines that its manifest 140 represents the same collection of data as manifest 160 and retrieves manifest 160. Remote node 102 determines that manifest 140, with a root hash of {999}, is not synchronized with manifest 160, which has a root hash of {772}. Remote node 102 then determines the set difference between its manifest 140 and manifest 160. In this example, manifest 140 is missing the content object identified by a name of “fruit/lychee/peel” with a digest of {41}, so remote node 102 sends an interest to local node 106 for the content object based on that name and digest. Local node 106 returns the requested content object. At time T5.a, remote node 102 updates it manifest 140 with the missing content object. Based on the contents of manifest 140 at time T5.a, the system generates a new root hash for manifest 140. This is depicted by the root hash value of manifest 140 at time T5.a: {999}♯{772}. Thus, at time T5.a, manifest 140 at node 102 is in sync with manifest 160 at node 106. Nodes 102 and 106 have synchronized their collections and both contain the same root hash value of {772}.
Local and Remote Manifests Contain Content Object with Same Name, but Different Digest: Remote Node Retrieves Manifest First
FIG. 6D presents tables depicting the format of two manifests during synchronization, where the digest of a same named content object in the local manifest is different from the digest in the remote manifest, and where the local node advertises its manifest, in accordance with an embodiment of the present invention. At time T3, remote node 102 receives a hash advertisement from local node 106 of manifest 160, with a root hash of {53}. Remote node 102 determines that its manifest 140 represents the same collection of data as manifest 160 and retrieves manifest 160. Remote node 102 determines that its manifest 140, with a root hash of {999}, is not synchronized with manifest 160, which has a root hash of {53}. Remote node 102 then determines the set difference between its manifest 140 and manifest 160. In this example, manifest 140 is missing the content object identified by the name of “/fruit/lychee/peel” with a digest of {41}, so remote node 102 sends an interest to local node 106 for the content object based on that name and digest. Local node 106 returns the requested content object. At time T4.b, remote node 102 updates its manifest 140 with the missing content object. Based on the contents of manifest 140 at time T4.b, the system generates a new root hash for manifest 140. This is depicted by the root hash value of manifest 140 at time T4.b: {999}♯{772}. However, manifest 160, with its original root hash of {53}, is now out of sync with manifest 140, which has a new root hash of {772}.
Subsequently, local node 106 receives a hash advertisement from remote node 102 of manifest 140, with the new root hash of {772}. Local node 106 determines that its manifest 160 represents the same collection of data as manifest 140 and retrieves manifest 140. Local node 106 determines that its manifest 160, with a root hash of {53}, is not synchronized with manifest 140, which has a root hash of {772}. Local node 106 then determines the set difference between its local manifest 160 and remote manifest 140. In this example, manifest 160 is missing the content object identified by the name of “/fruit/lychee/peel” with a digest of {41}, so local node 106 sends an interest to remote node 102 for the content object based on that name and digest. Remote node 102 returns the requested content object. At time T5.b, local node 106 updates its manifest 160 with the missing content object. Based on the contents of manifest 160 at time T5.b, the system generates a new root hash for manifest 160. This is depicted by the root hash value of manifest 160 at time T5.b: {53} ♯ {772}. Thus, at time T5.b, manifest 140 at node 102 is in sync with manifest 160 at node 106. Nodes 102 and 106 have synchronized their collections and both contain the same root hash value of {772}.
FIGS. 6C and 6D illustrate that any node can be a remote or a local node, and that the order of sending or receiving hash advertisements, manifests, and content objects determined to be different associated with the manifest may differ depending on the contents in a collection at a given time, e.g., the contents of manifests 140 and 160 at times [T3, T4.a, T5.a] and at times [T3, 15 T4.b, T5.b]. That is, any node can send or receive a hash advertisement, transfer a manifest, and synchronize the contents of a manifest at the node using the methods described in this disclosure, thereby resulting in the synchronization of data collections at two nodes.
Synchronization Using Modified Time
FIG. 6E presents tables depicting the format of two manifests during synchronization, when the digest and modified time of a same named content object in the local manifest is different from the digest in the remote manifest, in accordance with an embodiment of the present invention. At time T6, local node 106 receives a hash advertisement from remote node 102 of manifest 140, with a root hash of {999}. Local node 106 determines that its manifest 160 represents the same collection of data as remote manifest 140 and retrieves manifest 140. Local node 106 determines that local manifest 160, with a root hash of {80}, is not synchronized with remote manifest 140, which has a root hash of {999}. Local node 106 then determines the set difference between its local manifest 160 and remote manifest 140. In this example, both manifest 140 and manifest 160 indicate a modified time 134 corresponding to each content object represented in its collection. The system determines that a content object with the same name in manifest 140 and manifest 160 has a different digest and a different modified time.
It should be noted that a modified time can include information relating to the second, minute, hour, day, month, and year that a corresponding content object was modified. For simplicity, the exemplary manifests in FIG. 6E contain only a time of day. Manifest 140 contains a content object identified by a name of “/chef/events/calendar.txt” with a digest of {1} and a modified time of 8:05 am. Manifest 160 contains a content object identified by the same name with a different digest of {320} and a different modified time of 7:30 am. Local node 106 then sends an interest to remote node 102 for the content object based on the name and digest of the different content object. Remote node 102 returns the requested content object.
Local node 106 determines that the content object from remote manifest 140 with a modified time of 8:05 am is more recent than the content object from its local manifest 160 with a modified time of 7:30 am. So, at time T7, local node 106 updates its manifest 160 with the different and more recent content object. Based on the contents of manifest 160 at time T7, the system generates a new root hash for manifest 160. This is depicted by the root hash value of manifest 160 at time T7: {80}♯{999}. Thus, at time T7, manifest 160 at local node 106 is in sync with manifest 140 at remote node 102. Nodes 102 and 106 have synchronized their collections and both contain the same root hash value of {999}.
In some embodiments, the system will retain the previous version of the changed content object (e.g., the content object identified by name “/chef/events/calendar.txt” with a digest of {320} and a modified time of 7:30 am) in a history field of manifest 160. In other embodiments, when remote node 102 receives a hash advertisement from local node 106 of manifest 160 with a root hash of {80} and downloads the local manifest 160, remote node 102 determines that the version of the received content object identified by name “/chef/events/calendar.txt” with a digest of {320} and a modified time of 7:30 am is less recent than the version in its own manifest. In this case, manifest 140 at remote node 102 remains out of sync with manifest 160 at local node 106. The manifests will undergo synchronization at a later time when local node 106 receives a hash advertisement from remote node 102 of manifest 140, which contains the more recently updated content object, as described above.
Secure Synchronization of Manifest Using a Hash Chain
In the embodiments of the present invention, in addition to the three-part name comprising a routable prefix, identification of the relevant namespace, and a root hash value of the manifest, an interest of advertisement for a manifest also carries a hash of a content object. FIG. 7A illustrates an exemplary secure synchronization of manifests, in accordance with an embodiment of the present invention. During operation, node 102 transmits a send_advertisement interest 712 (i.e., an interest of advertisement), which is a hash advertisement containing the root hash value of its manifest identified by collection name “/a/b.” In addition, interest 712 further comprises a first content hash (denoted as contenthash_1). The first content hash is the cryptographic hash of the first segment (i.e., segment 0) of the manifest, as described in conjunction with FIG. 2. A cryptographic hash is a hash generated based on the cryptographic identity (e.g., a key) of a node. This allows network 100 to disambiguate all potential segment 0's of the manifest to the one given by the content object hash.
If another node 104 also includes the manifest, the first content hash of node 104 (denoted as contenthash_2) can be different than contenthash_1. Node 104 also transmits a send_advertisement interest 714. Upon receiving interests 712 and 714, node 106 can determine from which node the manifest should be obtained. In some embodiments, nodes 102 and 104 use a distributed election to pick one hash chain for both nodes 102 and 104 to use. This leads to reduction of the multiplicity of hashes used to describe one manifest. In some embodiments, the hash chain with the largest hash value is elected. Suppose that contenthash_1 has a higher value than contenthash_2. As a result, node 104 retrieves the first segment of the manifest from node 102 by sending an interest of data in response to interest 712 and obtains the first content hash of the corresponding hash chain.
If node 102 is a valid publisher (i.e., a valid publisher node), node 104 obtains the entire hash chain of node 102 and begins advertising the hash value of node 102. However, the node with the larger content hash value may not be a trusted publisher. For example, adverse node 702 can also transmit a malicious send_advertisement interest 716 (denoted with a dotted line) with the largest hash value. If the key of node 702 is not trusted, node 104 can discard such an interest of advertisement and continue advertising the hash of node 104. Node 106, seeing multiple interests (e.g., interests 712, 714, and 716) for a manifest, can select the largest content object hash of node 702 first. However, because the corresponding hash chain is not from a trusted publisher, node 106 tries another interest of advertisement based on a selection policy. Examples of the selection policy include, but are not limited to, the order of content hash values and a random order to avoid a front-loading attack. Suppose that contenthash_1 has the highest hash value. Node 106 then sends a request_remote_manifest interest 722 comprising contenthash_1.
If adverse node 702 fabricates the root hash (denoted as roothash_1), node 702 can flood the network with one or more fabricated content object hashes (e.g., contenthash_3). Node 106 retrieves the first segment of the fabricated advertisement to look at a key identifier and determines whether node 702 is a trusted participant. Because the key identifier of node 702 is fabricated, node 106 does not trust interest of advertisement 716. On the other hand, if adverse node 702 uses a true root hash but fabricates the content object hash, node 106 retrieves the first segment corresponding to a respective interest of advertisement (e.g., interests 712, 714, and 716) to look at the corresponding key identifier and determines whether the node is an acceptable participant. Node 106 can stop this iteration after the first acceptable advertisement and follow its hash chain. Because a node must follow a hash chain, pipelining the download is limited by the fan-out of the hash chain.
FIG. 7B illustrates an exemplary hash chain for secure synchronization of manifests, in accordance with an embodiment of the present invention. Suppose that a manifest 700 is segmented into n segments 736.1-736.n (i.e., manifest segments 0 to (n−1)). A respective manifest segment is in a respective content objects 730.1-730.n, which are represented by names 732.1-732.n, respectively. A name includes a prefix, an identification of the relevant namespace, a root hash of manifest 700, and a content object hash (i.e., the hash of the corresponding content object). For example, name 732.1 includes the root hash of manifest 700 and the hash of content object 730.1. This allows the network to disambiguate all potential segment 0's of manifest 700 to the one given by the content object hash. Inside each content object of manifest 700 is the hash of the next manifest segment. This allows secure chaining of manifest segments from an interest of advertisement corresponding to segment 0.
In this example, the content object representation of manifest 700 results in n objects. Working backwards from the final object, the content object hash of the next object is inserted into the previous object in a distinguished field. It should be noted that the last content object of the manifest may not have a hash of the next content object and the corresponding field can be empty. The hashes for content objects 730.1-730.n are 738.1-738.n, respectively (it should be noted that 738.n is not shown on FIG. 7B). In some embodiments, a respective hash is generated using key identifier 734 associated with a node hosting the manifest. This key identifier 734 can be included in a respective content object. The hash of content object 730.4 (not shown on FIG. 7B) is 738.4 and is included in the previous content object 730.3. Similarly, the hash for content object 730.3 is 738.3 and is included in the previous content object 730.2. In this way, the first content object 730.1 includes the hash 738.2 of the next content object 730.2.
In some embodiments, a respective content object in manifest 700 includes a signature of the content object. For example, content objects 730.1, 730.2, 730.3, . . . , 730.n include signatures 740.1, 740.2, 740.3, . . . , 740.n, respectively. A signature corresponds to a signature of the rest of the elements in the corresponding content object. For example, signature 740.1 is a signature of {name 730.1, key identifier 734, manifest segment 0, hash 738.2}.
Once the first content object 730.1 is generated, the first hash 738.1 of the hash chain is generated. The first content object hash of 738.1 covers the content object and the hash chain pointer. Therefore, the interest of advertisement for secure synchronization is represented by a name comprising the collection name, an identification of the relevant namespace (e.g., “adv”), a root hash of manifest 700, and content object hash 738.1. If a respective node has a different key identifier, each node produces a unique hash chain, even for the same manifest 700. As a result, the interest of advertisement based on key identifier 734 is unique and interest aggregation at the forwarder is avoided. However, if a node already knows the hash of manifest 700, that node does not need to retrieve each instance of manifest 700, so long as the node has at least one instance from a trusted source.
Operations of Secure Synchronization of Manifest Using a Hash Chain
FIG. 8A presents a flowchart illustrating the process of a node securely synchronizing a local manifest using a hash chain, in accordance with an embodiment of the present invention. During operation, the node creates respective content objects of a manifest comprising corresponding segments S0-Sn (operation 802). Starting from Sn, the node selects the current content object (operation 804), computes a hash for the current content object and inserts the hash into the previous content object (operation 806). The node then checks whether the current object is the first content object (operation 808). If not, the node selects the previous content object as the current content object (operation 810) and continues to compute the hash for the current content object and insert the hash into the previous content object (operation 806). If the current content object is the first content object, the node transmits an interest of advertisement with the content object name comprising a prefix (or collection name), a namespace identification (e.g., “adv” or “data”), the root hash of the manifest, and the first content object hash corresponding to segment S0 (operation 812).
FIG. 8B presents a flowchart illustrating the process of a node initiating a secure synchronization of a remote manifest using a hash chain, in accordance with an embodiment of the present invention. During operation, the node receives one or more interests of advertisement with content object name comprising a prefix, a namespace identification, and the root hash of the manifest; and obtain respective initial segment of manifests corresponding to the respective interest of advertisements (operation 852). In the example n FIG. 7B, upon receiving advertisement 712, the node obtains segment 0 of manifest 700 (i.e., content object 730.1). It should be noted that the node includes a manifest and may require synchronization, as described in conjunction with FIG. 2. The node identifies the largest content object hash value (operation 854) and checks whether the manifest is from a valid (or trusted) publisher (operation 856). In the example in FIG. 7B, key identifier 734 is used for checking the valid publisher. If not, the node discards the corresponding manifest (operation 858) and continues to identify the next largest content object hash value (operation 854).
If the interest is from a valid publisher, the node checks whether the root hash is different than the local root hash (operation 862). If the root hash is different, the node initiates the synchronization process (operation 870), as described in conjunction with FIG. 3. Otherwise, the node determines whether the valid identified content object hash value is larger than the local content object hash value (operation 864). If the valid identified content object hash value is larger than the local content object hash value (operation 866), the node obtains the hash chain with the larger content object hash value (operation 868).
FIG. 8C presents a flowchart illustrating the process of a node securely synchronizing a remote manifest using a hash chain, in accordance with an embodiment of the present invention. During operation, the node transmits an interest of data with content object name comprising a prefix, the corresponding namespace identification (e.g., “data”), the root hash, and the content hash corresponding to S0 (operation 882). The node receives the content object with manifest segment, extracts the manifest segment, and obtains the content object hash of the next content object (operation 884). The node then checks for more content objects (operation 886). If there are more content objects, the node transmits an interest of data with content object name comprising the prefix, the namespace identification, the root hash, and the content object hash of the next content object (operation 888). Otherwise, the node constructs the manifest from received manifest segments (operation 890).
Secure Synchronization of Manifest Using Secure Catalog
In the embodiments of the present invention, in addition to the three-part name comprising a routable prefix, identification of the relevant namespace, and a root hash value of the manifest, an interest of advertisement for a manifest also carries a hash of a content object. This content object can correspond to a secure catalog comprising hash values of the respective content objects of the manifest. Rather than advertising the content object hash of the first segment of the manifest, a node may advertise the name of a secure catalog that enumerates all segments of the manifest. In some embodiments, the secure catalog can also be segmented. This can allow a faster performance by pipelining a download because a device may retrieve a plurality of segments of the catalog after one round trip.
This embodiment has a further benefit. Because it uses a secure catalog for the signature, the individual content objects that comprise the manifest are not publisher specific. Therefore, the hash values of the content objects do not depend on which has node generated the catalog, thereby improving the caching and reusing.
FIG. 9A illustrates an exemplary secure catalog for secure synchronization of manifests, in accordance with an embodiment of the present invention. In this example, a secure catalog 900 for manifest 700 includes name 732.1 of the first content object 730.1 of manifest 700. Catalog 900 also lists content object hashes 738.1-738.n of manifest 700. In some embodiments, content objects of manifest 700 are unsigned and can be identical for every publisher with the same manifest 700. The only difference is the signature of secure catalog 900. If secure catalog 900 of manifest 700 is too large for a single content object, the subsequent objects after the first content object can be unsigned and identical among publishers. Only the first segment of the secure catalog can contain publisher-specific information, such as a signature and timestamps, and use a secure method, such as hash chains, to later segments of the catalog.
In this example, a system breaks manifest 700 into n content objects 730.1-730.n, with hashes 738.1-738.n, respectively. In some embodiments, content objects 730.1-730.n do not include publisher-specific data and are unsigned. The system creates a secure catalog 900 with entries comprising hashes 738.1-738.n. Catalog 900 can be signed. The content object of catalog 900 can have a hash <cataloghash>. The resulting interest of advertisement has a name of the form “/a/b/adv/<roothash>/<cataloghash>.” Secure catalogs from multiple publishers for the same manifest may use a distributed election to converge on one secure catalog. Examples of a distributed election include, but are not limited to, the largest and the smallest hash value. One advantage of secure synchronization using secure catalog is that the content objects of the catalog can be identical among all publishers. As a result, the distributed election is only for using the secure catalog name. In some embodiments, the contents of the catalog can be identical among all publishers for the same manifest hash.
FIG. 9B illustrates an exemplary secure synchronization of manifests using a secure catalog, in accordance with an embodiment of the present invention. During operation, node 102 transmits a send_advertisement interest 912 (i.e., an interest of advertisement), which is a hash advertisement containing the root hash value of its manifest identified by collection name “/a/b” and the hash of a corresponding secure catalog (e.g., catalog 900) <cataloghash>. The interest takes the form of: “/a/b/advkroothash>/<cataloghash>.” This secure catalog includes respective content object hashes of the segments of the manifest. Node 106 receives the interest and sends a request_catalog interest 914 (i.e., an interest of data) comprising an interest of the first segment of the catalog. Interest 914 can take the form: “/a/b/datakroothash>/catalog/S0, content hash=<cataloghash>.” In other words, when the node requests the data with a content object hash, that hash value is in a distinct field of interest 914 and may not be incorporated in the name.
In some embodiments, upon receiving the interest of data, node 102 signs the catalog (procedure 932) and sends a send_catalog message 916 comprising the corresponding content object (CO). This message 916 includes the first segment S0 of the catalog and takes the form: “/a/b/datakroothash>/catalog/S0+payload,” wherein the payload contains the requested segment of the catalog. The hash of the content object in message 916 is <cataloghash> (i.e., hash(CO)=<cataloghash>). Upon receiving the catalog, node 106 verifies the signature of node 102 to ensure that node 102 is the valid publisher of the catalog and retrieves the respective content object hash (procedure 934). Node 106 then sends a set of interests for the segments of the manifest. The set of interests is segmented based on a segmentation protocol. The interests are sent in a request_manifest_in_segments message 918 (i.e., an interest of data), and are of the form: “/a/b/data/<roothash>/<contenthash_1>”, “/a/b/data/<roothash>/contenthash_2,” “/a/b/data/<roothash>/contenthash_3,” etc. In the example FIG. 9A, <contenthash_1>, <contenthash_2>, and <contenthash_3> correspond to hashes 738.1, 738.2, and 738.3, respectively.
Operations of Secure Synchronization of Manifest Using Secure Catalog
FIG. 10A presents a flowchart illustrating the process of a node securely synchronizing a local manifest using a secure catalog, in accordance with an embodiment of the present invention. During operation, the node creates respective content objects of a manifest comprising corresponding segments S0-Sn (operation 1002). The node creates a catalog for the manifest with a name corresponding to the name of the first content object corresponding to segment S0 (operation 1004). Starting from S0, the node selects the current content object (operation 1006), and computes a hash for the current content object and inserts the hash into the catalog (operation 1008). The node then checks whether the current object is the last content object (operation 1010). If not, the node selects the next content object as the current content object (operation 1012) and continues to compute the hash for the current content object and insert the hash into the catalog (operation 1008).
If the current content object is the last content object, the node signs the catalog, and transmits an interest of advertisement with the catalog name comprising a prefix (or collection name), a namespace identification (e.g., “adv”), the root hash of the manifest, and the hash of the catalog comprising the signature of the catalog (i.e., the signature of the catalog is a part of the hash of the catalog) (operation 1014). The node receives an interest of data with the catalog name comprising the prefix, the namespace identification (e.g., “data”), the root hash of the manifest, and the hash of the catalog (operation 1016). The node transmits the signed catalog based on the catalog name (operation 1018), as described in conjunction with FIG. 9B.
FIG. 10B presents a flowchart illustrating the process of a node securely synchronizing a remote manifest using a secure catalog, in accordance with an embodiment of the present invention. During operation, the node receives an interest of advertisement with the catalog name comprising a prefix (or collection name), a namespace identification (e.g., “adv”), the root hash of the manifest, and the hash of the catalog (operation 1052). It should be noted that the node includes a manifest and may require synchronization, as described in conjunction with FIG. 2. The node transmits an interest of data with the catalog name comprising the prefix, the namespace identification (e.g., “data”), the root hash of the manifest, and the hash of the catalog (operation 1054). The node receives a signed catalog and verifies the signature (operation 1056).
The node then checks whether the catalog is a valid catalog (operation 1058) based on the signature verification. If the catalog is valid, the node obtains a respective content object hash of a corresponding manifest segment from the catalog (operation 1060). The node then initiates the secure synchronization process by transmitting a respective interest of data with a corresponding content object name comprising the prefix, the namespace identification, the root hash, and the respective content object hash from the catalog (operation 1062).
Computer System
FIG. 11 illustrates an exemplary computer and communication system that facilitates secure synchronization of manifests in a CCN, in accordance with an embodiment of the present invention. Computer and communication system 1102 includes a processor 1104, a memory 1106, and a storage device 1108. Memory 1106 can include a volatile memory (e.g., RAM) that serves as a managed memory, and can be used to store one or more memory pools. Furthermore, computer and communication system 1102 can be coupled to a display device 1110, a keyboard 1112, and a pointing device 1114. Storage device 1108 can store an operating system 1116, a secure content-processing system 1118, and data 1132.
Secure content-processing system 1118 can include instructions, which when executed by computer and communication system 1102, can cause computer and communication system 1102 to perform methods and/or processes described in this disclosure. Specifically, secure content-processing system 1118 can facilitate secure synchronization of manifests in a CCN. In some embodiments, secure content-processing system 1118 can be executed on a plurality of computer and communication systems, which are able to exchange data that describes the state of the operation associated with secure content-processing system 1118.
In summary, embodiments of the present invention provide a computer system and a method that facilitates secure synchronization of manifests in a CCN. During operation, the system generates an interest of advertisement comprising a name of a content object of the system. This name represents a collection of objects of the system and includes a first hash that is based on a key of the system. The first hash corresponds to a respective content object hash of one or more segments of a manifest representing the collection of objects. The system also determines a request for the content object based on the name in an interest of data from a remote node.
The data structures and code described in this detailed description are typically stored on a computer-readable storage medium, which may be any device or medium that can store code and/or data for use by a computer system. The computer-readable storage medium includes, but is not limited to, volatile memory, non-volatile memory, magnetic and optical storage devices such as disk drives, magnetic tape, CDs (compact discs), DVDs (digital versatile discs or digital video discs), or other media capable of storing computer-readable media now known or later developed.
The methods and processes described in the detailed description section can be embodied as code and/or data, which can be stored in a computer-readable storage medium as described above. When a computer system reads and executes the code and/or data stored on the computer-readable storage medium, the computer system performs the methods and processes embodied as data structures and code and stored within the computer-readable storage medium.
Furthermore, the methods and processes described above can be included in hardware modules or apparatus. The hardware modules or apparatus can include, but are not limited to, application-specific integrated circuit (ASIC) chips, field-programmable gate arrays (FPGAs), dedicated or shared processors that execute a particular software module or a piece of code at a particular time, and other programmable-logic devices now known or later developed. When the hardware modules or apparatus are activated, they perform the methods and processes included within them.
The foregoing descriptions of embodiments of the present invention have been presented for purposes of illustration and description only. They are not intended to be exhaustive or to limit the present invention to the forms disclosed. Accordingly, many modifications and variations will be apparent to practitioners skilled in the art. Additionally, the above disclosure is not intended to limit the present invention. The scope of the present invention is defined by the appended claims.

## Claims

1. A computer-executable method, comprising:
generating, by a computing device, an advertisement of a collection of content objects stored at the computing device, wherein a name included in the advertisement is a hierarchically structured variable length identifier which comprises contiguous name components ordered from a most general level to a most specific level,
wherein a last component of the name for the advertisement is a first hash that is based on a key of the computing device,
wherein the first hash is a hash of one or more segments of a manifest representing the collection of content objects,
wherein a segment of a manifest is distinct from a content object associated with the collection; and
receiving a request for a content object associated with the collection based on a name of a received interest of data from a remote node, wherein the last component of the name of the received interest is the first hash.

2. The method of claim 1, wherein the requested content object is a first segment of the manifest; and
wherein the requested content object comprises a second hash of a second segment of the manifest.

3. The method of claim 2, further comprising electing, based on the advertisement, the manifest at the computing device from a plurality of manifests with a same manifest hash, wherein the plurality of manifests is distributed among a plurality of nodes.

4. The method of claim 1, wherein the requested content object is a secure catalog at the computing device, wherein the secure catalog comprises the respective content object hash of the segments of the manifest, and wherein the first hash is a hash of the secure catalog.

5. The method of claim 4, further comprising signing the secure catalog using the key of the computing device.

6. The method of claim 4, further comprising electing, based on the advertisement, the secure catalog at the computing device from a plurality of secure catalogs with the same content object hash, wherein the plurality of secure catalogs is distributed among a plurality of nodes.

7. The method of claim 4, wherein the secure catalog is distributed among a plurality of segments; and
wherein a content object of a first segment of the secure catalog includes a hash of a content object of a second segment of the secure catalog.

8. The method of claim 4, further comprising generating a message comprising a segment of the manifest in response to an interest of data from a remote node for the segment, wherein the interest of data includes one of the content object hashes in the secure catalog.

9. The method of claim 1, wherein the key of the computing device identifies the computing device as a trusted publisher.

10. A computer-executable method, comprising:
obtaining, by a computing device, a name included in an advertisement from a remote node, wherein the name represents a collection of objects at the remote node and is a hierarchically structured variable length identifier which comprises contiguous name components ordered from a most general level to a most specific level,
wherein a last name component of the name for the advertisement is a first hash that is based on a key of the remote node,
wherein the first hash is a hash of one or more segments of a manifest representing the collection of content objects,
wherein a segment of a manifest is distinct from a content object associated with the collection; and
generating for the remote node an interest of data comprising a request for the collection of content objects based on the name.

11. A non-transitory computer-readable storage medium storing instructions that when executed by a computer cause the computer to perform a method, the method comprising:
generating an advertisement of a collection of content objects stored at a local node, wherein a name included in the advertisement is a hierarchically structured variable length identifier which comprises contiguous name components ordered from a most general level to a most specific level,
wherein a last component of the name for the advertisement is a first hash that is based on a key of the local node,
wherein the first hash is a hash of one or more segments of a manifest representing the collection of content objects,
wherein a segment of a manifest is distinct from a content object associated with the collection; and
receiving a request for a first content object associated with the collection based on a name of a received interest of data from a remote node, wherein the last component of the name of the received interest is the first hash.

12. The non-transitory computer-readable storage medium of claim 11, wherein the requested content object is a first segment of the manifest; and
wherein the requested content object comprises a second hash of a second segment of the manifest.

13. The non-transitory computer-readable storage medium of claim 11, wherein the method further comprises electing, based on the advertisement, the manifest at the local node from a plurality of manifests with a same manifest hash, wherein the plurality of manifests is distributed among a plurality of nodes.

14. The non-transitory computer-readable storage medium of claim 11, wherein the requested content object is a secure catalog at the local node, wherein the secure catalog comprises the respective content object hash of the segments of the manifest, and wherein the first hash is a hash of the secure catalog.

15. The non-transitory computer-readable storage medium of claim 14, wherein the method further comprises signing the secure catalog using the key of the local node.

16. The non-transitory computer-readable storage medium of claim 14, wherein the method further comprises electing, based on the advertisement, the secure catalog at the local node from a plurality of secure catalogs with the same content object hash, wherein the plurality of secure catalogs is distributed among a plurality of nodes.

17. The non-transitory computer-readable storage medium of claim 14, wherein the secure catalog is distributed among a plurality of segments; and
wherein a content object of a first segment of the secure catalog includes a hash of a content object of a second segment of the secure catalog.

18. The non-transitory computer-readable storage medium of claim 14, wherein the method further comprises generating a message comprising a segment of the manifest in response to an interest of data from a remote node for the segment, wherein the interest of data includes one of the content object hashes in the secure catalog.

19. The non-transitory computer-readable storage medium of claim 11, wherein the key of the local node identifies the local node as a trusted publisher.

20. A non-transitory computer-readable storage medium storing instructions that when executed by a computer cause the computer to perform a method, the method comprising:
obtaining a name included in an advertisement from a remote node, wherein the name represents a collection of objects at the remote node and is a hierarchically structured variable length identifier which comprises contiguous name components ordered from a most general level to a most specific level,
wherein a last name component of the name for the advertisement is a first hash that is based on a key of the remote node,
wherein the first hash is a hash of one or more segments of a manifest representing the collection of content objects,
wherein a segment of a manifest is distinct from a content object associated with the collection; and
generating for the remote node an interest of data comprising a request for the collection of content objects based on the name.