EP2859701A1 - VERFAHREN ZUM UMWANDELN VON AUSGANGSDATEN IN ZIELDATEN GEMÄß ASN.1 - Google Patents

VERFAHREN ZUM UMWANDELN VON AUSGANGSDATEN IN ZIELDATEN GEMÄß ASN.1

Info

Publication number
EP2859701A1
EP2859701A1 EP13728708.2A EP13728708A EP2859701A1 EP 2859701 A1 EP2859701 A1 EP 2859701A1 EP 13728708 A EP13728708 A EP 13728708A EP 2859701 A1 EP2859701 A1 EP 2859701A1
Authority
EP
European Patent Office
Prior art keywords
asn1
public
integer
data
value
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Ceased
Application number
EP13728708.2A
Other languages
English (en)
French (fr)
Inventor
Christoph Pfeiffer
Robert CZERWONKA
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Bundesdruckerei GmbH
Original Assignee
Bundesdruckerei GmbH
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Bundesdruckerei GmbH filed Critical Bundesdruckerei GmbH
Publication of EP2859701A1 publication Critical patent/EP2859701A1/de
Ceased legal-status Critical Current

Links

Classifications

    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L69/00—Network arrangements, protocols or services independent of the application payload and not provided for in the other groups of this subclass
    • H04L69/06—Notations for structuring of protocol data, e.g. abstract syntax notation one [ASN.1]

Definitions

  • the present invention relates to the conversion of output data into target data according to ASN.1.
  • the application relates to an ASN1 annotation framework for
  • ASN.1 is a description language for the definition of data structures as well as definitions for the implementation of data structures and elements in a network-uniform format.
  • ASN.1 is a common standard of the ITU-T (International Telecommunication Union - Telecommunication Standardization Sector) and the ISO (International Organization for Standardization).
  • the ASN.1 standard is used for the abstract description of data types without, however, going into the computer-internal representation of data types.
  • the notation is defined in the ITU-T standards X.680ff.
  • the associated standards X.690ff define various encoding rules that specify how the ASN.1 data values are encoded at the bit level. Using ASN.1 and a common encoding rule, systems with different internal data representations can exchange messages.
  • the object according to the invention is achieved by a method for converting output data into target data according to ASN.1, with the steps of reading in at least one digital conversion instruction for converting the
  • Conversion instruction This allows an ASN.1 transformation to be created automatically and in a computationally efficient way.
  • the method is carried out according to an embodiment automatically by means of a data processing system, in particular by means of one or more processors.
  • the output data, the target data, and the at least one or more conversion instructions are digitized and represented, for example, by electronic signals or states of electronic components.
  • the at least one conversion instruction therefore constitutes, according to one embodiment, an instruction to a digital data processing system which causes the data processing system to automatically convert the data.
  • the conversion is automatically performed according to one embodiment. For this purpose, either a conversion routine can be executed automatically or it can be set up for this purpose
  • the data format is a digital data format that specifies, for example, a temporal arrangement of digital values of the output data or of data components of the output data.
  • the conversion instruction is provided in a source code.
  • the source code may, for example, be in digital form, for example in the form of
  • Binary values be stored in electronic components and so be digitally readable.
  • the electronic components are formed, for example, by memory chips, ROM or RAM memory.
  • the source code is a class definition.
  • the class definition is stored in a memory and serves as an abstract model or blueprint for a series of similar objects.
  • Class definition can be stored, for example, in digital form, for example in the form of binary values, in electronic components and thus be digitally readable.
  • the method comprises the step of parsing the source code for reading in the conversion instruction.
  • the process of parsing achieves the technical advantage that the conversion instructions can be easily determined and extracted by systematically analyzing source codes stored in electronic components.
  • the parser may be formed as a separate circuit or as a program component that parses the digitally-stored source code grammatically and / or syntactically.
  • the method comprises the step of invoking a converter for reading in the conversion instruction and generating the target data.
  • the converter may be formed, for example, by a separate processor or integrated circuit on a circuit board that processes the digital conversion signals.
  • the converter is formed by a routine or program that runs on a data processing system.
  • the method comprises the step of controlling the converter via the conversion instruction.
  • signals for controlling the converter can be transmitted in a technically particularly simple manner.
  • the method comprises the step of calling the converter via an object.
  • the technical advantage is achieved, for example, that the converter can be called and started in a technically simple manner in an object-oriented programming language directly from an object and reduced complexity of a call.
  • the object is a data storage area in an execution environment whose contents can represent values. Every object has a state, a behavior and an identity.
  • the object is in binary form in
  • the state of the object consists of its properties (attributes) and connections to other objects.
  • the behavior of the object is described by the set of its methods. The identity
  • the method comprises the step of reading out the conversion instruction from a class definition of the calling object.
  • Conversion data can be obtained in a simple technical way when calling the object from the class definition and reduces a required storage space for the conversion instructions.
  • the method comprises the step of generating the target data from object data.
  • the technical advantage is achieved, for example, that the target data can be generated automatically via the exchange of digital signals.
  • the object data is data stored in an electronic component representing the object.
  • the method comprises the step of returning the target data via the calling object.
  • the target data forms an ASN.1 sequence.
  • the ASN.1 sequence is over
  • the technical advantage is achieved that the ASN.1 signals can be transmitted in a network layer to other data processing systems.
  • the method comprises the step of mapping one conversion instruction each to one data type of the output data.
  • the data type represents a summary of concrete value ranges and operations defined thereon according to an embodiment, and defines the storage format of the value ranges in electronic components.
  • the object according to the invention is achieved by a converter for converting output data into target data according to ASN.1, having a
  • An input device for reading in at least one digital conversion instruction for converting the output data in a first data format into the destination data in a second data format; and generating means for generating the target data from the output data according to the conversion instruction.
  • Converter can be realized in software and / or hardware.
  • a computer program product that can be loaded directly into the internal memory of a digital computer and includes software code portions that perform the method of the first aspect when the product is run on a computer. This achieves the same technical advantages as the method according to the first aspect.
  • FIG. 1 is a schematic representation of individual method steps
  • FIG. Fig. 2 is a schematic view of a framework
  • Fig. 3 is a flowchart of a simple flow
  • Fig. 4 is a flowchart of a complex flow
  • Fig. 5 is a block diagram of a sequence of actions in creating and parsing
  • Fig. 6 is a table of Java base types and ASN1 base types
  • FIG. 1 illustrates the operation of the ASN1 framework method according to one embodiment.
  • the conversion process of the output data 100 into the target data 101 can be started directly by a corresponding function call.
  • the annotations 103 provided in the ASN1 object are referred to hereafter as annotations or annotations.
  • the object itself becomes the step S101 of converting
  • step S102 of the reading in the annotations 103 of the object are determined, which are called
  • Conversion instruction to convert data into a network uniform format If further complex objects are located in a tree, a determination of the annotations 103 is also made here. Then, in step S103 of interpreting, the ASN1 framework 105 causes the ASN1 structure to be created using an underlying ASN1 converter, such as bouncycastle. This structure is now returned to the logical code in step S104 of the return, i. the caller,
  • step S105 which can then be fetched from the ASNI bytes in step S105 (result).
  • the object is first analyzed. All are
  • Map ⁇ MapType, Object> map findASNI TypeAnnotation (clazz);
  • Annotation asnITypeAnnotation (annotation) map.get (MapType.ASNI);
  • map.get MapType.ConstraintList
  • ASN1 ClassDefinition (asn1 type annotation, asnl constraints, clazz); However, this code fragment does not include the complete logic.
  • ASN1 FieldDefinition similar to the ASN1 ClassDefinition, includes the entirety of the field and annotations in that field.
  • the following code fragment shows the logical processing:
  • ASNUag tag field.getAnnotation (ASNUag.class);
  • ASN1 FieldDefinition (asn1 TypeAnnotation, field, clazz, readMethod_, writeMethod);
  • this code fragment also does not include the complete logic. In order to determine a correct ASN1 annotation, it is checked whether this itself by means of
  • ASNIType and ASN1nnformation annotation has been annotated.
  • An example of a typical ASN1 type annotation is:
  • the advantage of the ASN1 framework is the speed of implementation. For example, up to 80% of the time can be saved.
  • the following section shows a comparison between traditional usage and the use of the ASN1 framework:
  • the code of the ASN1 object is: public class DEROId implements DEREncodable ⁇
  • ASNI Object obj ASNI Object.fromByteArray (buffer);
  • str ((DERUTF8String) SEQUENCE.getObjectAt (1)). getString ();
  • DERTaggedObject tag10 new DERTaggedObject (10, intValue);
  • DERTaggedObject tagl 1 new DERTaggedObject (1 1, strValue);
  • the object is created via:
  • byteQ buffer obj.getDERObject (). getDEREncodable ();
  • the parsing is done via:
  • the object is created via:
  • byteQ buffer obj.getDERObject (). getDEREncodable ();
  • the parsing is done via:
  • DEROId obj DERRoot.getlnstance (buffer, DEROId.class);
  • Each class that is to be used as a stand-alone ASN1 object inherits from the DERRoot class. In this class is all the code logic to parse and create the ASN1 byte arrays through the annotations. Each class has an ASN1 type for this purpose, whether it is of a simple type (integer, boolean, ...) or complex type complex (SEQUENCE, SET).
  • Each field to be used to create the bytecode also has a simple ASN1 type annotated.
  • FIG. 2 gives a first overview of the structure of the ASN1 framework 200, in which only the handlers for the simple ASN1 types are shown in simplified form.
  • the basis of the ASN1 framework 200 is the object DERRoot.
  • This object has the inherited method createDERObject from the bouncycastle framework and the static method getlnstance, which realizes the parsing.
  • step 309 the routine create DERObject () is executed, with the transition to create DERObject (this) in step 31 1. From step 31 1, a transition to step 313 with handleClassAnnotation (Object): DERObject takes place, in which convert (Object): DERObject is executed.
  • FIG. 4 shows a diagram of a complex ASN.1 generation (ASN.1) 301 process 401, with the further entity sequence handler 403.
  • the routine create DERObject () is executed, with the transition to create DERObject (this) to step 407.
  • a transition to step 407 with handleClassAnnotation (Object): DERObject occurs at step 413.
  • a transition is made to step 409 with getFields): List ⁇ Fields>.
  • step 409 may optionally be skipped to step 413.
  • the routines checkFields () and sortFields () can be executed, after which a transition to step 41 1 with generateVector (fields): Vector can be performed. After that can with
  • step 414 a transition to step 414 take place. From step 414, a transition may be made to step 41 1 and from there to step 413 respectively. After that, in step 413, the routine createDERObject (Vector): DERObject may be executed. After this, a transition to step 407 can be made.
  • Vector createDERObject
  • FIG. 5 shows a diagram of a method 501 according to an embodiment, in which it is clarified in which order the actions during creation and parsing are executed.
  • step 503 "Find ASN1 Type Annotation on Class” is executed. Then it is decided whether creation / parsing (handling complex) should be executed. Depending on the decision, step 507, "Handle simple type” or 509, "Handle Sequences / Sets”, is executed. From step 507, scheduling takes place in step 527.
  • step 51 1 "find all fields with ASN1 type annotation” is executed, and then it is decided at step 513 whether to proceed to step 525 or one of steps 517, 519, or 521
  • the complex processing is performed in step 519, "creation / parsing (handling complex)".
  • the optional routine "Handle Sequence” is executed in step 519.
  • step 521 the routine "handle simple type” is executed. From steps 517, 519 and 521, a transition to step 523 takes place, from where a transition to step 525 can take place. From step 525, scheduling takes place in step 529, "End.”
  • byteQ buffer new HexBinaryAdapter (). Unmarshal ("020100");
  • MyObject obj DERRoot.getlnstance (buffer, MyObject.class);
  • Fig. 6 shows simple and complex types of the ASN1 framework.
  • Simple types are primarily basic types of ASN1 specifications, such as integer, boolean or octet string. These simple data types can be mapped to different Java base types, i. be mapped.
  • the table shown in Figure 6 shows which Java base types can be used for which ASN1 base types.
  • all fields can use the ASN1 base type from the bouncycastle framework. All listed ASN1 types, except for null, which is only applied to classes, can map these types to both fields and classes.
  • the value field serves as a target field for the actual value extracted from the ASN1 byte array or used to create the ASN1 byte array.
  • this annotation could also be on a Get method of the field:
  • the ASN1 base type is attached to a field.
  • the class itself represents a sequence (SEQUENCE) that consists of only one field, namely an ASNIInteger.
  • ASN1 SEQUENCEField The meaning of ASN1 SEQUENCEField will be explained later.
  • the value field is marked as ASNIInteger. Alternatively, the following annotation would also be possible here:
  • the value 100 results in the following ASN byte array: 3003020164.
  • ASN1 base types there are complex types and objects to represent more complex structures.
  • SEQUENCE sequence
  • SET set
  • CHOICE choice
  • SEQUENCE is similar to SET with the difference that in SEQUENCE the order is freely selectable, whereas in SET this is prescribed by the ASN1 specification.
  • SEQUENCE is given by:
  • ASN1 SEQUENCEField ASN1 SEQUENCEField with a corresponding position.
  • the position is any number that is not duplicated within SEQUENCE.
  • the order then results from the sorting of the fields based on this item number.
  • a field can also be marked as optional. This field can also be null.
  • ASNISETField all fields that should become part of SET are marked with the annotation ASNISETField.
  • no positions can be specified here for individual fields, since, as already mentioned above, the order can not be set in SET. Again, optional fields are possible.
  • MyObjectB :: SEQUENCE ⁇
  • the code demonstrates how to insert a complex object into another complex object.
  • Value2 of the type MyObjectA is marked with ASN1 Complex and indicates that this is an intrinsically complex object.
  • This example gives rise to two interleaved S £ QL / £ / VC £ regions.
  • the opi / ona / attribute can also be used for complex fields.
  • the procedure is analogous with SET.
  • CHOICE defines that only one of the listed fields may be used. The other fields remain null.
  • the following example describes a simple CHOICE:
  • the CHOICE fields should be unique. If complex objects are used, they should also be unique in their own structure with respect to CHOICE.
  • the tag types exist: the CONSTRUCTED-Jag and the APPLICATION tag. These tags can be placed in front of each object for uniqueness. This procedure is advantageous for SEQUENCE and SET if they have several optional fields of the same type.
  • the number attribute specifies the tag number, while the type attribute specifies the tag type, which in this case is CONS TR UC TED. If only valuel is set with the value 100, the result is the ASN byte array: 3005A003020164.
  • SEQUENCE is tagged again. In particular, implicit tagging then throws an ASN1 option.
  • the value of the valuel field ASN byte array resulting from this example is: 30055003020164
  • double tagging is usually allowed, there should be no actual double tagging, such as re-tagging MyObject in another SEQUENCE. Especially with implicit tagging an ASN1 - Exeption is thrown.
  • Implicit tagging in the ASN1 annotation framework works like this:
  • the corresponding fields can be an enumeration.
  • the enumeration should return a value that is valid for the ASN1 type.
  • the following example shows the use of enumerations:
  • the enumeration has two methods: the getValue method to get the actual enumeration value and the getEnum method to get the actual enumeration constant over the value. These two methods are set in the annotation ASNIEnum.
  • the findMethod attribute requires a method that takes the expected value and tries to return it to an enumeration constant.
  • the getMethod attribute requires a method that returns an actual valid value that is set by the
  • Enumeration constant is given. This annotation can be used for a field, for example within SEQUENCE.
  • Bit strings are typically used to store the state of multiple flags. Each boolean flag, which can either be set or not set, is inserted into this bit string. This is to be implemented in the ASN1 annotation framework as follows:
  • the individual bits are represented by Boolean parameters.
  • ASN1 bytecode When the ASN1 bytecode is generated, a byte array of sufficient length is generated. The unused bytes are marked as unusedbits. This calculation can be switched off via the attribute calculateBitsPadding. If this attribute is false then unusedbits will be set to 0.
  • the ASN1 annotation framework provides a way to use the inheritance. This can also take place over several classes.
  • the base type of a field may be an interface or an abstract class
  • the annotations are located only on abstract classes or the field interface, not on inherited, overlying interfaces. This is prevented by the multiple inheritance of interfaces.
  • the following example shows a simple inheritance.
  • the base is an interface that implements the concrete classes:
  • an interface is declared, which provides the required get methods (getters) and set methods (setters).
  • the interface should inherit from class DERInterface. This ensures that the object is actually an ASN1 object.
  • the DERRoot class implements this interface. All classes that implement the declared interface are listed there using the annotation ASN1Abstract ⁇ m attribute implementors in a list. This tells the parser which classes to include.
  • the inherited objects should be unique, otherwise an exception ASN1 exception will be thrown. To remedy the situation, the uniqueness of an identifier (identifier) can be ensured.
  • MyAbstractObject ⁇ MyBase ⁇ :: SEQUENCE ⁇
  • MyObject :: MyAbstractObject ⁇ 1, UTF8String ⁇
  • the base is marked as SEQUENCE.
  • the already known fields valuel and value2 are provided with a S £ QL / £ / VC £ position.
  • a special feature is the variable value2, whose type is still unknown and is only set in the implementing class of the Get method of the field. The field should be protected or the Get method should be protected and overwritable.
  • MyObject ⁇ MyClass: MyClassTable ⁇ :: SEQUENCE ⁇ protocol MyClass. & Id,
  • MyObject_String extends ASN1AbstractTestObjectWithSET ⁇ String> ⁇
  • the class is used to describe the type by means of an ID, the protocol field is mapped to id, and the value field is mapped to the ASN1 type, which depends on the ID.
  • ASNIOpenType is also of type AnnotationType.
  • AnnotationType is a type that represents an annotation.
  • ASNIIntegerType is the representation of the ASNIInteger annotation. The type can simply be converted into a valid one by the method toAnnotation
  • Annotation be converted. Within the framework, these types are used to pass the ASN1 type type as an ASN1 class definition.
  • the ASN1 annotation types can also be given the entire attributes of the known ASN1 type annotations via the constructor or via set methods.
  • identifiers are assigned that uniquely identify an object. This shows the following example:
  • CA_DH_3DES_CBC_CBC (BSIIdentifier.lD_CA_DH_3DES_CBC_CBC), CA_ECDH_3DES_CBC_CBC (BSIIdentifier.lD_CA_ECDH_3DES_CBC_CBC); public static ChipAuthenticationProtocol fromOID (String oid) ⁇
  • ChipAuthenticationProtocol item ChipAuthenticationProtocol. valuesQ
  • ChipAuthenticationProtocol item ChipAuthenticationProtocol.values ()) ⁇ if (item.getold (). equals (oid))
  • PK_DH (BSIIdentifier.lD_PK_DH), PK_ECDH (BSIIdentifier.lD_PK_ECDH); public static ChipAuthenticationPublicKeyProtocol fromOID (String oid) ⁇ for (ChipAuthenticationPublicKeyProtocol item:
  • ChipAuthenticationPublicKeyProtocol.valuesO ⁇
  • ChipAuthenticationPublicKeyProtocol.valuesO ⁇
  • ChipAuthenticationPublicKeyProtocol.fromOID (protocolOID.getld ());

Landscapes

  • Engineering & Computer Science (AREA)
  • Computer Security & Cryptography (AREA)
  • Computer Networks & Wireless Communication (AREA)
  • Signal Processing (AREA)
  • Devices For Executing Special Programs (AREA)
  • Stored Programmes (AREA)

Abstract

Die Erfindung betrifft ein Verfahren zum Umwandeln von Ausgangsdaten (100) in Zieldaten (101) gemäß ASN.1 mit den Schritten eines Einlesens (S102) zumindest einer digitalen Umwandlungsanweisung (103) zum Umwandeln der Ausgangsdaten (100) in einem ersten Datenformat in die Zieldaten (101) in einem zweiten Datenformat und eines Erzeugens (S103) der Zieldaten (101) aus den Ausgangsdaten (100) gemäß der Umwandlungsanweisung (103).

Description

VERFAHREN ZUM UMWANDELN VON AUSGANGSDATEN IN ZIELDATEN GEMÄß
ASN.1
Die vorliegende Erfindung betrifft die Umwandlung von Ausgangsdaten in Zieldaten gemäß ASN.1 . Insbesondere betrifft die Anmeldung ein ASN1 -Annotation-Framework zur
Umsetzung von Rechner-internen Datenstrukturen und Elementen in ein netzeinheitliches Format.
Die Abstract Syntax Notation One (ASN.1 ) ist eine Beschreibungssprache zur Definition von Datenstrukturen sowie Festlegungen zur Umsetzung von Datenstrukturen und Elementen in ein netzeinheitliches Format. ASN.1 ist gemeinsamer Standard der ITU-T (International Telecommunication Union - Telecommunication Standardization Sector) und der ISO (Internationale Organisation für Normung).
Der ASN.1 -Standard dient der abstrakten Beschreibung von Datentypen, ohne jedoch auf die rechnerinterne Darstellung von Datentypen einzugehen. Die Notation ist in den ITU-T- Standards X.680ff definiert. Die zugehörigen Standards X.690ff definieren verschiedene Kodierungsregeln, welche angeben, wie die ASN.1 -Datenwerte auf Bit-Ebene kodiert werden. Mit Hilfe von ASN.1 und einer gemeinsamen Encoding Rule können Systeme mit unterschiedlichen internen Datendarstellungen Nachrichten austauschen.
Es ist die Aufgabe der vorliegenden Erfindung, ein effizientes Konzept zur Umsetzung von Daten in ein netzeinheitliches Format gemäß ANS.1 zu schaffen.
Diese Aufgabe wird durch die Merkmale der unabhängigen Ansprüche gelöst. Vorteilhafte Ausführungsformen sind Gegenstand der abhängigen Ansprüche, der Beschreibung sowie der Zeichnungen.
Gemäß einem ersten Aspekt wird die erfindungsgemäße Aufgabe durch ein Verfahren zum Umwandeln von Ausgangsdaten in Zieldaten gemäß ASN.1 gelöst, mit den Schritten eines Einlesens zumindest einer digitalen Umwandlungsanweisung zum Umwandeln der
Ausgangsdaten in einem ersten Datenformat in die Zieldaten in einem zweiten Datenformat und eines Erzeugens der Zieldaten aus den Ausgangsdaten gemäß der
Umwandlungsanweisung. Dadurch kann eine ASN.1 Umwandlung automatisch und recheneffizient erstellt werden. Das Verfahren wird gemäß einer Ausführungsform automatisiert mittels einer Datenverarbeitungsanlage, insbesondere mittels eines oder mehrerer Prozessoren ausgeführt. Die Ausgangsdaten, die Zieldaten sowie die zumindest eine oder mehrere Umwandlungsanweisungen sind digitalisiert und werden beispielsweise durch elektronische Signale oder Zustände von elektronischen Bauteilen repräsentiert. In dem Schritt des Einlesens werden gemäß einer Ausführungsform digitale Daten, welche die
Umwandlungsanweisung repräsentieren, automatisch eingelesen. Die zumindest eine Umwandlungsanweisung stellt gemäß einer Ausführungsform daher eine Anweisung an eine digitale Datenverarbeitungsanlage dar, welche die Datenverarbeitungsanlage zum automatischen Umwandeln der Daten veranlasst. Das Umwandeln wird gemäß einer Ausführungsform automatisch durchgeführt. Hierzu kann automatisch entweder eine Umwandlungsroutine ausgeführt werden oder es kann ein hierzu eingerichteter
Verarbeitungsschaltkreis eingesetzt werden, welcher die Umwandlung vornimmt. Das Datenformat ist ein digitales Datenformat, das beispielsweise eine zeitliche Anordnung von digitalen Werten der Ausgangsdaten oder von Datumsbestandteilen der Ausgangsdaten festlegt.
In einer vorteilhaften Ausführungsform ist die Umwandlungsanweisung in einem Quellcode vorgesehen. Dadurch wird beispielsweise der technische Vorteil erreicht, dass bereits beim Kompilieren des Quellcodes die Umwandlungsregeln gewonnen werden können. Der Quellcode kann beispielsweise in digitaler Form, beispielsweise in der Gestalt von
Binärwerten, in elektronischen Bauelementen gespeichert sein und so digital einlesbar sein. Die elektronischen Bauteile werden beispielsweise durch Speicherchips, ROM- oder RAM- Speicher, gebildet.
In einer weiteren vorteilhaften Ausführungsform ist der Quellcode eine Klassendefinition. Dadurch wird beispielsweise der technische Vorteil erreicht, dass sich die
Umwandlungsanweisungen von einer objektorientierten Programmiersprache für jedes aus der Klasse abgeleitete Objekt verwenden lassen und sich der technische Aufwand für ein Kompilieren verringert. Die Klassendefinition ist in einem Speicher gespeichert und dient als ein abstraktes Modell oder ein Bauplan für eine Reihe von ähnlichen Objekten. Die
Klassendefinition kann beispielsweise in digitaler Form, beispielsweise in der Gestalt von Binärwerten, in elektronischen Bauelementen gespeichert sein und so digital einlesbar sein.
In einer weiteren vorteilhaften Ausführungsform umfasst das Verfahren den Schritt eines Parsens des Quellcodes zum Einlesen der Umwandlungsanweisung. Durch den technischen Prozess des Parsens wird beispielsweise der technische Vorteil erreicht, dass sich die Umwandlungsanweisungen einfach durch systematisches Analysieren von Quellcodes ermitteln und extrahieren lassen, die in elektronischen Bauteilen gespeichert sind. Der Parser kann als eine separate Schaltung oder als eine Programmkomponente gebildet sein, die den digital gespeicherten Quellcode grammatikalisch und/oder syntaktisch analysiert.
In einer weiteren vorteilhaften Ausführungsform umfasst das Verfahren den Schritt eines Aufrufens eines Umwandlers zum Einlesen der Umwandlungsanweisung und Erzeugen der Zieldaten. Dadurch wird beispielsweise der technische Vorteil erreicht, dass die Umwandlung von einer getrennten Instanz durchgeführt wird und sich eine Stabilität und Zuverlässigkeit des Verfahrens auf einer Datenverarbeitungsanlage verbessert. Der Umwandler kann beispielsweise durch einen separaten Prozessor oder eine integrierte Schaltung auf einem Schaltungsbrett gebildet sein, der die digitalen Umwandlungssignale verarbeitet. In einer anderen Ausführungsform ist der Umwandler durch eine Routine oder ein Programm gebildet, das auf einer Datenverarbeitungsanlage läuft.
In einer weiteren vorteilhaften Ausführungsform umfasst das Verfahren den Schritt eines Steuerns des Umwandlers über die Umwandlungsanweisung. Dadurch wird beispielsweise der technische Vorteil erreicht, dass sich die technischen Einsatz- und
Konfigurationsmöglichkeiten des Umwandlers erhöhen. Insbesondere können Signale zum Steuern des Umwandlers in technisch besonders einfacher Weise übertragen werden.
In einer weiteren vorteilhaften Ausführungsform umfasst das Verfahren den Schritt eines Aufrufens des Umwandlers über ein Objekt. Dadurch wird beispielsweise der technische Vorteil erreicht, dass der Umwandler in technisch einfacher Weise in einer objektorientierten Programmiersprache direkt aus einem Objekt heraus aufgerufen und gestartet werden kann und sich eine Komplexität eines Aufrufs verringert. Das Objekt ist ein Datenspeicherbereich in einer Ausführungsumgebung, dessen Inhalte Werte darstellen können. Jedes Objekt hat einen Zustand, ein Verhalten und eine Identität. Das Objekt ist in binärer Form in
elektronischen Bauelementen gespeichert. Der Zustand des Objektes setzt sich aus seinen Eigenschaften (Attribute) und Verbindungen zu anderen Objekten zusammen. Das Verhalten des Objektes wird durch die Menge seiner Methoden beschrieben. Die Identität
unterscheidet ein Objekt von anderen Objekten, auch wenn diese anderen Objekte den gleichen Zustand und das gleiche Verhalten haben. In einer weiteren vorteilhaften Ausführungsform umfasst das Verfahren den Schritt eines Auslesens der Umwandlungsanweisung aus einer Klassendefinition des aufrufenden Objektes. Dadurch wird beispielsweise der technische Vorteil erreicht, dass die
Umwandlungsdaten auf einfache technische Weise bei einem Aufrufen des Objektes aus der Klassendefinition gewonnen werden können und sich ein benötigter Speicherplatz für die Umwandlungsanweisungen verringert.
In einer weiteren vorteilhaften Ausführungsform umfasst das Verfahren den Schritt eines Erzeugens der Zieldaten aus Objektdaten. Dadurch wird beispielsweise der technische Vorteil erreicht, dass die Zieldaten über den Austausch von digitalen Signalen automatisch erzeugt werden können. Die Objektdaten sind in einem elektronischen Bauteil gespeicherte Daten, die das Objekt darstellen.
In einer weiteren vorteilhaften Ausführungsform umfasst das Verfahren den Schritt eines Zurückgebens der Zieldaten über das aufrufende Objekt. Dadurch wird beispielsweise der technische Vorteil erreicht, dass die Zieldaten nach der Rückgabe weiter verarbeitet werden können und sich die Anzahl von Speicherzugriffen vermindert.
In einer weiteren vorteilhaften Ausführungsform formen die Zieldaten eine ASN.1 -Sequenz. Dadurch wird beispielsweise der technische Vorteilerreicht, dass die Zieldaten mit einer geringen Anzahl von Signalen direkt an ein Netzwerk ausgegeben werden können.
In einer weiteren vorteilhaften Ausführungsform wird die ASN.1 -Sequenz über ein
Datennetzwerk übertragen. Dadurch wird beispielsweise der technische Vorteil erreicht, dass die ASN.1 -Signale in einer Netzwerkschicht zu anderen Datenverarbeitungsanlagen übertragen werden können.
In einer weiteren vorteilhaften Ausführungsform umfasst das Verfahren den Schritt eines Abbildens je einer Umwandlungsanweisung auf je einen Datentyp der Ausgangsdaten.
Dadurch wird beispielsweise der technische Vorteil erreicht, dass sich für jeden Datentyp eine entsprechende Umwandlung durchführen lässt und sich der Aufwand zum Analysieren der digitalen Umwandlungsanweisungen vermindert. Der Datentyp stellt gemäß einer Ausführungsform eine Zusammenfassung konkreter Wertebereiche und darauf definierten Operationen zu einer Einheit dar und definiert das Speicherformat der Wertebereiche in elektronischen Bauteilen. Gemäß einem zweiten Aspekt wird die erfindungsgemäße Aufgabe durch einen Umwandler zum Umwandeln von Ausgangsdaten in Zieldaten gemäß ASN.1 gelöst, mit einer
Einlesevorrichtung zum Einlesen zumindest einer digitalen Umwandlungsanweisung zum Umwandeln der Ausgangsdaten in einem ersten Datenformat in die Zieldaten in einem zweiten Datenformat; und einer Erzeugungsvorrichtung zum Erzeugen der Zieldaten aus den Ausgangsdaten gemäß der Umwandlungsanweisung. Dadurch werden die gleichen technischen Vorteile wie durch das Verfahren nach dem ersten Aspekt erreicht. Der
Umwandler kann in Software und/oder in Hardware realisiert werden.
Gemäß einem dritten Aspekt wird die erfindungsgemäße Aufgabe durch ein
Computerprogrammprodukt gelöst, das direkt in den internen Speicher eines digitalen Computers geladen werden kann und Softwarecodeabschnitte umfasst, mit denen das Verfahren nach dem ersten Aspekt ausgeführt wird, wenn das Produkt auf einem Computer läuft. Dadurch werden die gleichen technischen Vorteile wie durch das Verfahren nach dem ersten Aspekt erreicht.
Weitere Ausführungsbeispiele werden in Bezug auf die Zeichnungen beschrieben Es zeigen: Fig. 1 eine schematische Darstellung einzelner Verfahrensschritte; Fig. 2 eine schematische Ansicht eines Frameworks; Fig. 3 ein Ablaufdiagramm eines einfachen Flusses; Fig. 4 ein Ablaufdiagramm eines komplexen Flusses;
Fig. 5 ein Blockdiagramm einer Reihenfolge der Aktionen beim Erstellen und Parsen;
Fig. 6 eine Tabelle mit Java-Basistypen und ASN1 -Basistypen;
Fig. 7 eine Tabelle mit Deklarationsmöglichkeiten für ein Feld; und
Fig. 8 eine Tabelle mit in der ASN1 -Sprache existierenden Constraint-Annotationen.
Fig. 1 veranschaulicht die Funktionsweise des ASN1 -Framework-Verfahrens gemäß einer Ausführungsform. Auf dem selbst erstellten ASN1 -Objekt, das mit zusätzlichen Anmerkungen 103 versehen wird, kann direkt durch einen entsprechenden Funktionsaufruf 107 getDERObject der Umwandlungsprozess der Ausgangsdaten 100 in die Zieldaten 101 gestartet werden. Die in dem ASN1 -Objekt bereitgestellten Anmerkungen 103 werden im Folgenden als Annotationen oder Annotations bezeichnet.
Bei der Umwandlung wird das Objekt in Schritt S101 des Konvertierens selbst zur
Konvertierung verwendet und an interne Handler des ASN1 -Frameworks 105 weitergeleitet, das als eine Umwandlungseinrichtung dient. Durch das ASN1 -Framework 105 werden in Schritt S102 des Einlesens die Annotationen 103 des Objektes ermittelt, die als
Umwandlungsanweisung zum Umwandeln von Daten in ein netzeinheitliches Format dienen. Sollten sich weitere komplexe Objekte in einem Baum befinden, so wird auch hier eine Ermittlung der Annotationen 103 vorgenommen. Anschließend sorgt das ASN1 -Framework 105 in Schritt S103 des Interpretierens dafür, dass die ASN1 -Struktur mit Hilfe eines darunter liegenden ASN1 -Konverters, wie beispielsweise Bouncycastle erstellt wird. Diese Struktur wird in Schritt S104 der Rückgabe nun an den logischen Code, d.h. den Aufrufer,
zurückgegeben, der sich in Schritt S105 (Ergebnis) anschließend daraus die ASNI -Bytes abholen kann.
Im nachfolgenden Teil werden die technischen Funktionsweisen des ASN1 -Frameworks 105 und dessen Annotationen 103 in Zusammenhang mit der objektorientierten
Programmiersprache JAVA näher erläutert.
Bei der Verarbeitung wird zunächst das Objekt analysiert. Dabei werden sämtliche
Annotationen eingelesen, die an diesem Objekt hängen. Diese Gesamtheit wird durch ASN1 ClassDefinition beschrieben, die im nachfolgenden Code-Fragment erzeugt wird:
Map<MapType, Object> map = findASNI TypeAnnotation(clazz);
Annotation asnITypeAnnotation = (Annotation) map.get(MapType.ASNI );
List<ASN1 Constraints> asnI Constraints = (List<ASN1 Constraints>)
map.get(MapType.ConstraintList);
//Add all constraints annotations
ASN1 ClassDefinition asnl ClassDefinition = new
ASN1 ClassDefinition(asn1 TypeAnnotation, asnl Constraints, clazz); Dieses Code-Fragment beinhaltet jedoch nicht die vollständige Logik.
Darüber hinaus wird für jede Klasse eine Liste von ASN1 FieldDefinition angelegt.
ASN1 FieldDefinition beinhaltet, ähnlich wie die ASN1 ClassDefinition die Gesamtheit aus dem Feld und den Annotationen an diesem Feld. Das nachfolgende Code-Fragment zeigt die logische Verarbeitung:
//Use only fields (or its getter methods***) which annotated with a ASNUype Annotation asnUypeAnnotation = null;
for (Annotation annotation : field.getAnnotations()) {
if (annotation. annotationType().getAnnotation(ASN1Type.class) != null) { asnUypeAnnotation = annotation;
break;
}
}
//*** If not found a field with an ASNUype annotation and the read method exists //check this method annotations
if (asnUypeAnnotation == null && readMethod != null) {
for (Annotation annotation : read Method. getAnnotations()) {
if (annotation. annotationType().getAnnotation(ASN1 Type.class) != null) { asnUypeAnnotation = annotation;
break;
}
}
}
//Continue if this field is not annotated with a asnl type annotation
if (asnUypeAnnotation == null) {
return null;
}
//Get the base ASN1 Annotation and all its Information
ASNUag tag = field.getAnnotation(ASNUag.class);
if (tag == null && readMethod != null) { //Only if the tag was not found on field tag = readMethod. getAnnotation(ASNUag.class);
}
ASN1 Information Information =
asnUypeAnnotation.annotationType().getAnnotation(ASN1 Information. class); Method readMethod_ = null;
Method writeMethod = null;
ASN1 FieldDefinition asnI FieldDefinition = new
ASN1 FieldDefinition(asn1 TypeAnnotation, field, clazz, readMethod_, writeMethod);
Dieses Code-Fragment beinhaltet jedoch ebenfalls nicht die vollständige Logik. Um eine korrekte ASN1 -Annotation zu ermitteln, wird überprüft, ob diese selbst mittels der
ASNIType- und ASN1lnformation-Annotat\on mit Annotationen versehen worden ist. Ein Beispiel für eine typische ASN1 Type-Annotation ist:
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType. FIELD, ElementType.TYPE, ElementType. METHOD}) @ASN1 lnformation(complex = false, asnI CIass = {DERInteger.class,
DEROctetString.class}, tagNumber = ASNI Object. INTEGER) //Additional ASN1 - Information, must be set
@ASN1 Type //Make it to a ASN1 -Type-Annotation
public @interface ASN1 Integer {
* Mark integer as unsigned
*
* @ return
7
boolean unsigned() default false;
ASNI SingleValueConstraint singleValueConstraint() default
@ASN1 SingleValueConstraint("");
ASNIValueRangeConstraint valueRangeConstraint() default
@ASN1ValueRangeConstraint();
}
Der Vorteil des ASN1 -Frameworks liegt in der Geschwindigkeit der Implementierung. So können beispielsweise bis zu 80% der Zeit eingespart werden. Im folgenden Teil wird ein Vergleich zwischen der herkömmlichen Verwendung und der Verwendung des ASN1 - Frameworks gezeigt:
Dazu wird das ASN1 -Skript vorgegeben: Object ::= SEQUENCE {
valuel [10] INTEGER(0..100),
value2 [1 1] UTF8String OPTIONAL
}
Ohne die Verwendung des Frameworks ergibt sich der Code des ASN1 -Objektes: public class DEROId implements DEREncodable {
public static DEROId getlnstance(byte[] buffer) throws lOException { int value;
String str = null;
DERTaggedObject tag = null;
ASNI Object obj = ASNI Object.fromByteArray(buffer);
if (!(obj instanceof DERSEQUENCE))
throw new RuntimeException("Wrong type!");
DERSEQUENCE SEQUENCE = (DERSEQUENCE) obj;
if (SEQUENCE.size() < 1 )
throw new RuntimeException("Wrong size of SEQUENCE!");
if (!(SEQUENCE.getObjectAt(0) instanceof DERTaggedObject)) throw new RuntimeException("Wrong type!");
tag = (DERTaggedObject) SEQUENCE.getObjectAt(O);
if (tag.getNumber() != 10)
throw new RuntimeException("Wrong tag number!");
if (!(tag.getObject() instanceof DERInteger))
throw new RuntimeException("Wrong type!");
value = ((DERInteger) tag.getObject()).getPositiveValue().intValue(); //optional
if (SEQUENCE.size() > 1 ) {
if (!(SEQUENCE.getObjectAt(1 ) instanceof DERTaggedObject)) throw new RuntimeException("Wrong type!");
tag = (DERTaggedObject) SEQUENCE.getObjectAt(l );
if (tag.getNumber() != 1 1 )
throw new RuntimeException("Wrong tag number!"); if (!(tag.getObject() instanceof DERUTF8String))
throw new RuntimeException("Wrong type!");
str = ((DERUTF8String) SEQUENCE.getObjectAt(1 )).getString();
}
DEROId old = new DEROId(value, str);
validate(old);
return old;
}
//Validation
private static void validate(DEROId obj) {
if (obj.getValue1 () < 0 || obj.getValue1 () > 100)
throw new RuntimeException("Out of ränge!");
}
private int valuel ;
private String value2;
public DEROId() {
}
public DEROId(int valuel , String value2) {
this. valuel = valuel ;
this.value2 = value2;
}
public int getValue1 () {
return valuel ;
}
public void setValue1 (int valuel ) {
this. valuel = valuel ;
}
public String getValue2() {
return value2;
}
public void setValue2(String value2) {
this.value2 = value2;
}
public DERObject getDERObject() {
validate(this);
ASN1 EncodableVector vec = new ASN1 EncodableVectorQ; DERInteger intValue = new DERInteger(valuel );
DERTaggedObject tag10 = new DERTaggedObject(10, intValue);
vec.add(tagl O);
if (value2 != null) {
DERUTF8String strValue = new DERUTF8String(value2);
DERTaggedObject tagl 1 = new DERTaggedObject(1 1 , strValue);
vec.add(tag1 1 );
}
return new DERSEQUENCE(vec);
}
}
Das Erstellen des Objekts erfolgt über:
DEROId obj = new DEROId(10, "Hallo");
byteQ buffer = obj.getDERObject().getDEREncodable();
Das Parsen erfolgt über:
DEROId obj = DEROId.getlnstance(buffer);
Mit Verwendung des erfindungsgemäßen Frameworks ergibt sich der Code des ASN1 - Objektes:
@ASN1 SEQUENCE
public class DERNew extends DERRoot {
@ASN1 SEQUENCEField(position = 1 )
@ASN1 lnteger(
valueRangeConstraint = @ASN 1ValueRangeConstraint(minimum = 0, maximum = 100)
)
@ASN1Tag(number = 10, type = ASNI TagType.CONSTRUCTED)
private int valuel ;
@ASN1 SEQUENCEField(position = 2, optional = ASNI Optional.NotNull)
@ASN1 UTF8String
@ASN1Tag(number = 1 1 , type = ASNI TagType.CONSTRUCTED) private int value2;
public DERNew() {
}
public DERNew(int valuel , int value2) {
this.valuel = valuel ;
this.value2 = value2;
}
public int getValue1 () {
return valuel ;
}
public void setValue1 (int valuel ) {
this.valuel = valuel ;
}
public int getValue2() {
return value2;
}
public void setValue2(int value2) {
this.value2 = value2;
}
}
Das Erstellen des Objekts erfolgt über:
DEROId obj = new DEROId(10, "Hallo");
byteQ buffer = obj.getDERObject().getDEREncodable();
Das Parsen erfolgt über:
DEROId obj = DERRoot.getlnstance(buffer, DEROId.class);
Der größte Aufwand - die Implementierung des Erstellens und des Parsens - entfällt im Vergleich zu dem erstgenannten Beispiel. Das Verfahren kann mit weniger Rechenschritten und in geringerer Zeit durchgeführt werden. Dabei bleiben die Aufrufe, die im Code anzugeben sind, im Wesentlichen gleich. Jede Klasse, die als eigenständiges ASN1 -Objekt verwendet werden soll, erbt von der Klasse DERRoot. In dieser Klasse befindet sich die gesamte Code-Logik, um das Parsen und Erstellen der ASN1 -Byte-Arrays über die Annotationen auszuführen. Jede Klasse weist zu diesem Zweck einen ASN1 -Typen auf, unabhängig davon, ob dieser von einem einfachen Typ (Integer, Boolean, ...) oder von einem komplexen Typ komplex (SEQUENCE, SET) ist.
Jedes Feld, das zur Erstellung des Byte-Codes verwendet werden soll, weist ebenfalls einen einfachen ASN1 -Typ als Annotation auf.
Fig. 2 gibt einen ersten Überblick über den Aufbau des ASN1 -Frameworks 200, in dem vereinfacht lediglich die Handler für die einfachen ASN1 -Typen dargestellt sind.
Als Basis des ASN1 -Frameworks 200 dient das Objekt DERRoot. Dieses Objekt besitzt die vererbte Methode createDERObject aus dem Bouncycastle-Framework sowie die statische Methode getlnstance, die das Parsen realisiert. Für die auf beiden Seiten dargestellten Bereiche Parsing und Creation, existiert jeweils ein Root-Handler 201 und 203, der wiederum die Utility und diverse Objekt-Handler anspricht.
Fig. 3 zeigt ein Diagramm eines Verfahrens zur vereinfachten ASN.1 -Erzeugung 301 (ASN.1 Simple Creation) unter Verwendung der Entitäten Creation Root Handler 303, Creation Utility 305 und Integer Handler 307 dargestellt. Im Schritt 309 wird die Routine create DERObject() ausgeführt, mit dem Übergang mit create DERObject(this) in den Schritt 31 1. Von dem Schritt 31 1 aus findet ein Übergang in den Schritt 313 mit handleClassAnnotation(Object): DERObject statt, in welchem convert(Object): DERObject ausgeführt wird.
Fig. 4 zeigt ein Diagramm eines Verfahrens zur komplexen ASN.1 -Erzeugung 301 (ASN.1 Complex Creation) 401 , mit der weiteren Entität Sequence Handler 403. Im Schritt 405 wird die Routine create DERObject() ausgeführt, mit dem Übergang mit create DERObject(this) in den Schritt 407. Von dem Schritt 407 aus findet ein Übergang in den Schritt 407 mit handleClassAnnotation(Object): DERObject in den Schritt 413 statt. Von dem Schritt 413 aus findet ein Übergang in den Schritt 409 mit getFields) : List<Fields> statt. Hiernach kann von dem Schritt 409 optional in den Schritt 413 übergangen werden. Hiernach können die Routinen checkFields() und sortFields() ausgeführt werden, wonach ein Übergang in den Schritt 41 1 mit generateVector(fields): Vector erfogen kann. Danach kann mit
handleFieldAnnotation(DERObject) ein Übergang in den Schritt 414 stattfinden. Von dem Schritt 414 aus kann ein Übergang in den Schritt 41 1 und von dort aus in den Schritt 413 erfolgen. Hiernach kann im Schritt 413 die Routine createDERObject(Vector): DERObject ausgeführt werden. Hiernach kann ein Übergang in den Schritt 407 erfolgen.
Fig. 5 zeigt ein Diagramm eines Verfahrens 501 gemäß einer Ausführungsform, in dem verdeutlicht wird, in welcher Reihenfolge die Aktionen beim Erstellen und Parsen ausgeführt werden.
Beginnend mit„Start" wird der Schritt 503,„ Finde ASN1 -Type-Annotation auf Klasse" ausgeführt. Danach wird entschieden, ob Creation/Parsing (Handlingkomplex) ausgeführt werden sollen. In Abhängigkeit von der Entscheidung wird der Schritt 507,„Handle einfachen Typ" oder 509,„Handle Sequences/Sets", ausgeführt. Von dem Schritt 507 aus findet die Terminierung in dem Schritt 527 statt.
Nach dem Schritt 509 wird der Schritt 51 1 ,„Finde alle Felder mit ASN1 -Typ-Annotation" ausgeführt. Danach wird im Schritt 513 entschieden, ob mit dem Schritt 525 weiter verfahren werden soll, oder ob einer der Schritte 517, 519 oder 521 ausgeführt werden soll. Die komplexe Abarbeitung wird im Schritt 519,„Creation/Parsing (Handling komplex)" durchgeführt. Im Schritt 519 wird die optionale Routine„Handle Sequence" ausgeführt. Im Schritt 521 wird die Routine„Handle einfachen Typ" ausgeführt. Von den Schritten 517, 519 und 521 aus findet jeweils ein Übergang in den Schritt 523 statt, von wo aus ein Übergang in den Schritt 525 stattfinden kann. Von dem Schritt 525 aus findet die Terminierung in dem Schritt 529,„Ende", statt.
Das Erstellen eines Byte-Arrays von einem ASN1 -Annotation-Framework-Objekts wird durch folgenden Code erreicht: public class MyObject extends DERRoot {
public static void main(String[] args) {
MyObject obj = new MyObject();
obj.setValue(100);
DEREncodable derObj = obj.getDERObject();
byte[] array = derObj.getDEREncoded();
} }
Durch den Aufruf der Methode getDERObject wird der Vorgang eines Erstellens gestartet. Nach dem Aufruf wird ein Bouncycastle-Encodable erhalten, das nur noch aus Basis- Objekten besteht.
Das Parsen eines Byte-Arrays ist ebenfalls einfach: byteQ buffer = new HexBinaryAdapter().unmarshal("020100");
MyObject obj = DERRoot.getlnstance(buffer, MyObject.class);
Durch diese zwei Zeilen wird der Parsing-Algorithmus in DERRoot angestoßen.
Anschließend wird das komplett zusammengesetzte Objekt erhalten.
Fig. 6 zeigt einfache und komplexe Typen des ASN1 -Frameworks. Bei einfachen Typen handelt es sich in erster Linie um Basis-Typen der ASN1 -Spezifikationen, wie beispielsweise Integer, Boolean oder Octet-String. Diese einfachen Datentypen können auf verschiedenen Java-Basistypen abgebildet werden, d.h. gemappt, werden. Die in Fig. 6 dargestellte Tabelle zeigt, welche Java-Basistypen für welche ASN1 -Basis-Typen verwendet werden können.
Darüber hinaus können alle Felder den ASN1 -Basis-Typ aus dem Bouncycastle-Framework verwenden. Alle aufgeführten ASN1 -Typen, mit Ausnahme von null, der nur bei Klassen angewendet wird, können diese Typen sowohl auf Felder als auch auf Klassen gemappt werden.
Es gibt für jeden der oben aufgeführten Basis-Typen mit Ausnahme von null eine
Möglichkeit, eine Enumeration festzulegen, die eine Get- und eine Find- Methode besitzt. Der Typ, der für einen Enumeration-Wert verwendet wird, sollte mit den oben aufgeführten unterstützen Typen übereinstimmen.
Im folgenden Code als Klassenbeispiel wird eine Variable von Typ Integer definiert. Diese Deklaration verhält sich analog zur ASN1 -Deklaration:
MyObject ::= INTEGER
@ASN1 Integer
public class MyObject extends DERRoot {
@ASN1TargetField private Biginteger value;
public MyObject() {
super();
}
public MyObject(Biglnteger value) {
this. value = value;
}
public Biginteger getValue() {
return value;
}
public void setValue(Biglnteger value) {
this. value = value;
}
}
Hier wird die Klasse als ASNIInteger markiert. Das Feld value dient dabei als ein Zielfeld für den tatsächlichen Wert, der aus dem ASN1 -Byte-Array extrahiert wird oder zum Erstellen des ASN1 -Byte-Arrays verwendet werden soll. Alternativ könnte sich diese Annotation auch an einer Get-Methode des Feldes befinden:
@ASN1 Integer
public class MyObject extends DERRoot {
private Biginteger value;
public MyObject() {
super();
}
public MyObject(Biglnteger value) {
this. value = value;
}
@ASN1TargetField
public Biginteger getValue() {
return value;
}
public void setValue(Biglnteger value) {
this. value = value;
} }
Für einen Wert von 100 wird dabei folgender ASN1 -Byte-Code erstellt: 020164
In diesem Beispiel wird der ASN1 -Basis-Typ an ein Feld angeheftet. Die Klasse selbst repräsentiert dabei eine Sequenz (SEQUENCE), die nur aus einem einzigen Feld besteht, nämlich einem ASNIInteger.
MyObject ::= SEQUENCE {
value INTEGER
}
@ASN1 SEQUENCE
public class MyObject extends DERRoot {
@ASN1 Integer
@ASN1 SEQUENCEField(position = 1 )
private int value;
public int getValue() {
return value;
}
public void setValue(int value) {
this. value = value;
}
}
Die Bedeutung von ASN1 SEQUENCEField wird später erläutert. Das Feld value ist als ASNIInteger markiert. Alternativ wäre auch hier folgende Annotation möglich:
@ASN1 SEQUENCE
public class MyObject extends DERRoot {
@ASN1 SEQUENCEField(position = 1 )
private int value;
©ASNI Integer
public int getValue() {
return value;
}
public void setValue(int value) { this.value = value;
}
}
Bei diesem Beispiel entsteht mit dem Wert 100 folgendes ASN-Byte-Array: 3003020164.
Zusätzlich zu den ASN1 -Basis-Typen gibt es komplexe Typen und Objekte, um komplexere Strukturen darzustellen. Neben den Typen SEQUENCE (Sequenz) und SET (Menge) gibt es im ASN1 -Annotation-Framework auch eine Annotation für CHOICE (Wahl). Dabei können auch komplexe Unterobjekte in diese Strukturen aufgenommen werden.
SEQUENCE ist vergleichbar mit SET mit dem Unterschied, dass bei SEQUENCE die Reihenfolge frei wählbar ist, während diese bei SET durch die ASN1 -Spezifikation vorgeschrieben wird. Beispielsweise ist SEQUENCE gegeben durch:
MyObject ::= SEQUENCE {
valuel INTEGER,
value2 UTF8String
value3 INTEGER OPTIONAL
}
@ASN1 SEQUENCE
public class MyObject extends DERRoot {
@ASN1 Integer
@ASN1 SEQUENCEField(position = 1 )
private Integer valuel ;
//Type set on getter
@ASN1 SEQUENCEField(position = 2)
private String value2;
@ASN1 Integer
@ASN1 SEQUENCEField(position = 3, optional = ASN I Optional.NotNull)
private Integer value3;
public Integer getValuel () {
return valuel ;
}
public void setValuel (Integer valuel ) {
this. valuel = valuel ;
} @ASN1 UTF8String
public String getValue2() {
return value2;
}
public void setValue2(String value2) {
this.value2 = value2;
}
public Integer getValue3() {
return value3;
}
public void setValue3(lnteger value3) {
this.value3 = value3;
}
}
Die Klasse selbst wird hierbei mit einer ASN1 -SEQUENCE Annotation markiert. Jedes Feld, das Bestandteil von SEQUENCE werden soll, besitzt die Annotation ASN1 SEQUENCEField mit einer entsprechenden Position. Die Position ist eine beliebige Zahl, die innerhalb von SEQUENCE nicht doppelt vorkommt. Die Reihenfolge ergibt sich dann aus der Sortierung der Felder anhand dieser Positionsnummer. Darüber hinaus kann ein Feld auch als optional markiert werden. Dieses Feld kann auch null sein. Bei SET ist die Vorgehensweise analog:
MyObject ::= SET {
valuel INTEGER,
value2 UTF8String
value3 INTEGER OPTIONAL
}
@ASN1 SET
public class MyObject extends DERRoot {
@ASN1 Integer
@ASN1 SETField
private Integer valuel ;
//Type set on getter
@ASN1 SETField
private String value2;
@ASN1 Integer @ASN1 SETField(optional = ASNI Optional.NotNull)
private Integer value3;
public Integer getValuel () {
return valuel ;
}
public void setValuel (Integer valuel ) {
this. valuel = valuel ;
}
@ASN1 UTF8String
public String getValue2() {
return value2;
}
public void setValue2(String value2) {
this.value2 = value2;
}
public Integer getValue3() {
return value3;
}
public void setValue3(lnteger value3) {
this.value3 = value3;
}
}
Auch hier sind alle Felder, die Bestandteil von SET werden sollen, mit der Annotation ASNISETField markiert. Im Gegensatz zu SEQUENCE können hier keine Positionen für einzelne Felder angegeben werden, da, wie oben bereits erwähnt, die Reihenfolge bei SET nicht festgelegt werden kann. Auch hier sind optionale Felder möglich.
Es gibt die Möglichkeit, auch verschiedene komplexere Typen in SEQUENCE und SET zu verwenden und dadurch eine Verschachtelung von SEQUENCE- und SET-Bereichen zu erhalten:
MyObjectA ::= SEQUENCE {
valuel INTEGER,
value2 UTF8String,
value3 INTEGER OPTIONAL }
MyObjectB ::= SEQUENCE {
valuel INTEGER,
value2 MyObjectA
}
@ASN1 SEQUENCE
public class MyObjectA extends DERRoot {
@ASN1 Integer
@ASN1 SEQUENCEField(position = 1 )
private Integer valuel ;
//Type set on getter
@ASN1 SEQUENCEField(position = 2)
private String value2;
@ASN1 Integer
@ASN1 SEQUENCEField(position = 3, optional = ASN I Optional.NotNull) private Integer value3;
public Integer getValuel () {
return valuel ;
}
public void setValuel (Integer valuel ) {
this. valuel = valuel ;
}
@ASN1 UTF8String
public String getValue2() {
return value2;
}
public void setValue2(String value2) {
this.value2 = value2;
}
public Integer getValue3() {
return value3;
}
public void setValue3(lnteger value3) {
this.value3 = value3;
} }
@ASN1 SEQUENCE
public class MyObjectB extends DERRoot {
@ASN1 Integer
@ASN1 SEQUENCEField(position = 1 )
private Integer valuel ;
@ASN1 Complex
@ASN1 SEQUENCEField(position = 2)
private MyObjectA value2;
public Integer getValuel () {
return valuel ;
}
public void setValuel (Integer valuel ) {
this. valuel = valuel ;
}
public MyObjectA getValue2() {
return value2;
}
public void setValue2(MyObjectA value2) {
this.value2 = value2;
}
}
Der Code demonstriert, wie ein komplexes Objekt in ein anderes komplexes Objekt einfügt wird. Value2 vom Typ MyObjectA wird dabei mit ASN1 Complex markiert und zeigt an, dass es sich hierbei um ein inneres komplexes Objekt handelt. Aus diesem Beispiel entstehen zwei ineinander verschachtelte S£QL/£/VC£-Bereiche. Natürlich kann auch für komplexe Felder das opi/ona/-Attribut verwendet werden. Die Vorgehensweise ist bei SET analog.
In bestimmten Fällen soll lediglich ein bestimmtes Objekt innerhalb von SEQUENCE oder S£7 auftreten. Zu diesem Zweck ist in der ASN1 -Syntax den OF-Operator für SEQUENCE und SET vorgesehen. Im folgenden Beispiel wird ASN1 SEQUENCEOf verwendet:
MyObject ::= SEQUENCE OF INTEGER
@ASN1 SEQUENCEOf
public class MyObjectB extends DERRoot { @ASN1 Integer
@ASN1TargetField
private List<lnteger> value = new Arrayl_ist<lnteger>();
@Override
public void validate() {
}
public List<lnteger> getValue() {
return value;
}
}
Innerhalb von ASNISEQUENCEOf kann es nur eine Liste geben, die mit der Annotation ASNI TargetField markiert ist. Diese enthält dann immer wieder das gleiche Objekt, hier beispielsweise Integer. Allerdings können auch komplexe und abstrakte Objekte verwendet werden. Diese Vorgehensweise ist bei ASN1SETO† analog:
MyObject ::= SET OF INTEGER
@ASN1 SETOf
public class MyObjectB extends DERRoot {
@ASN1 Integer
@ASN1TargetField
private List<lnteger> value = new ArrayList<lnteger>();
public List<lnteger> getValue() {
return value;
}
}
CHOICE (Wahl) definiert, dass nur eines der aufgelisteten Felder verwendet werden darf. Die anderen Felder bleiben null. Das nachfolgende Beispiel beschreibt eine einfache CHOICE:
MyObject ::= CHOICE {
valuel INTEGER,
value2 UTF8String
}
@ASN1 Choice public class MyObject extends DERRoot {
@ASN1 Integer
private Integer valuel ;
//Type set on getter
private String value2;
@Override
public void validate() {
}
public Integer getValuel () {
return valuel ;
}
public void setValuel (Integer valuel ) {
this. valuel = valuel ;
}
@ASN1 UTF8String
public String getValue2() {
return value2;
}
public void setValue2(String value2) {
this.value2 = value2;
}
}
Hier wird nur eines der Felder valuel oder value2 gesetzt. Das jeweils andere Feld wird auf null gesetzt, da andernfalls eine ASN1 -Exception ausgegeben wird. In analoger Weise verhält es sich, wenn kein Feld gesetzt ist. Auch in diesem Fall können komplexe Objekte verwendet werden, solange die Felder eindeutig bleiben.
Die Felder CHOICE (Wahl) sollten eindeutig sein. Werden komplexe Objekte verwendet, sollten diese ebenfalls in ihrer eigenen Struktur in Bezug auf CHOICE eindeutig sein.
Andernfalls wird beim Parsen eine ASN1 -Exception geworfen. Allerdings ist auch eine Verwendung von Tags möglich.
In ASN1 existieren zwei verschiedene Möglichkeiten, ein Feld als optional zu deklarieren: Entweder das Feld wird mit null (0500) aufgefüllt oder es wird einfach weggelassen. Wird es mit null gefüllt, so bleibt auch der möglicherweise definierte Tag erhalten. Wird es einfach nur weggelassen, verschwindet auch der Tag. Fig. 7 zeigt die unterschiedlichen Möglichkeiten in Tabellenform.
Es gibt weitere Möglichkeiten, die Struktur der ASN1 -Bytes zu definieren. Darunter gehört in erster Linie das Verwenden von Tags, aber auch der Ausbau von noch komplexeren Feldern SEQUENCE und SET mittels des OF-Operators. Im nachfolgenden Teil wird auf diese ASN1 -Erweiterungen eingegangen.
In ASN1 existieren die Tag-Typen: Das CONSTRUCTED-Jag und das APPLICATION-Tag. Diese Tags können vor jedem Objekt angeordnet werden, um Eindeutigkeit zu erreichen. Diese Vorgehensweise ist bei SEQUENCE und SET von Vorteil, wenn diese mehrere optionale Felder des gleichen Typs besitzen.
In diesem Beispiel wird eine SEQUENCE erzeugt, dessen Felder mit einem
CONSTRUCTED-Jag versehen werden:
MyObject ::= SEQUENCE {
valuel [0] INTEGER OPTIONAL,
value2 [1 ] UTF8String OPTIONAL,
value3 [2] INTEGER OPTIONAL
}
@ASN1 SEQUENCE
public class MyObject extends DERRoot {
@ASN1 Integer
@ASN1 SEQUENCEField(position = 1 , optional = ASN I Optional.NotNull)
@ASN1Tag(number = 0, type = ASNI TagType .CONSTRUCTED)
private Integer valuel ;
//Type set on getter
@ASN1 SEQUENCEField(position = 2, optional = ASNI Optional.NotNull)
@ASN1Tag(number = 1 , type = ASNI TagType .CONSTRUCTED)
private String value2;
@ASN1 Integer
@ASN1 SEQUENCEField(position = 3, optional = ASN I Optional.NotNull)
@ASN1Tag(number = 2, type = ASNI TagType .CONSTRUCTED)
private int value3;
@Override public void validate() {
}
public Integer getValuel () {
return valuel ;
}
public void setValuel (Integer valuel ) {
this. valuel = valuel ;
}
@ASN1 UTF8String
public String getValue2() {
return value2;
}
public void setValue2(String value2) {
this.value2 = value2;
}
public int getValue3() {
return value3;
}
public void setValue3(int value3) {
this.value3 = value3;
}
}
In dem Beispiel sind alle Felder optional. Durch zwei Integer-Variable wäre die Zuordnung nicht mehr eindeutig. Durch die Tags und ihre Nummer bleibt die Zuordnung jedoch erhalten.
Das Attribut number gibt dabei die Tag-Nummer an, während das Attribut type den Tag-Typ angibt, der in diesem Fall CONS TR UC TED ist. Sollte lediglich valuel mit dem Wert 100 gesetzt sein, so ergibt sich das ASN-Byte-Array: 3005A003020164.
Tags können aber auch direkt an Klassen definiert werden:
MyObject ::= [0] INTEGER
@ASN1 Integer
@ASN1Tag(number = 0, type = ASNI TagType.CONSTRUCTED)
public class MyObject extends DERRoot { @ASN1TargetField
private Biginteger value;
public MyObject() {
super();
}
public MyObject(Biglnteger value) {
this. value = value;
}
public Biginteger getValue() {
return value;
}
public void setValue(Biglnteger value) {
this. value = value;
}
}
Auf diese Art und Weise kann die Klasse selbst dafür sorgen, einen eindeutigen Tag zu erhalten.
Obwohl normalerweise das doppelte Tagging erlaubt ist, sollte kein tatsächliches doppeltes Tagging erfolgen, wie beispielsweise, dass das Objekt MyObject in einer anderen
SEQUENCE nochmals getaggt wird. Insbesondere beim impliziten Tagging wird dann eine ASN1 -Exeption geworfen.
Analog zum CONSTRUCTED-Tag verhält es sich beim APPLICA 7/O/V-Tag :
MyObject ::= SEQUENCE {
valuel [APPLICATION 0] INTEGER OPTIONAL,
value2 [APPLICATION 1 ] UTF8String OPTIONAL,
value3 [APPLICATION 2] INTEGER OPTIONAL
}
@ASN1 SEQUENCE
public class MyObject extends DERRoot {
@ASN1 Integer
@ASN1 SEQUENCEField(position = 1 , optional = ASN1 Optional. NotNull)
@ASN1Tag(number = 0, type = ASNITagType.APPLICATION)
private Integer valuel ; //Type set on getter
@ASN1 SEQUENCEField(position = 2, optional = ASN I Optional.NotNull) @ASN1Tag(number = 1 , type = ASNITagType.APPLICATION)
private String value2;
@ASN1 Integer
@ASN1 SEQUENCEField(position = 3, optional = ASN I Optional.NotNull) @ASN1Tag(number = 2, type = ASNITagType.APPLICATION)
private int value3;
public Integer getValuel () {
return valuel ;
}
public void setValuel (Integer valuel ) {
this. valuel = valuel ;
}
@ASN1 UTF8String
public String getValue2() {
return value2;
}
public void setValue2(String value2) {
this.value2 = value2;
}
public int getValue3() {
return value3;
}
public void setValue3(int value3) {
this.value3 = value3;
}
}
Das aus diesem Beispiel resultierende ASN-Byte-Array mit dem Wert 100 für das Feld valuel ist: 30055003020164
Auch im folgenden Fall können Klassen mit diesem Tag versehen werden:
MyObject ::= [APPLICATION 0] INTEGER
@ASN1 Integer @ASN1Tag(number = 0, type = ASN UagType.APPLICATION)
public class MyObject extends DERRoot {
@ASN1TargetField
private Biginteger value;
public MyObject() {
super();
}
public MyObject(Biglnteger value) {
this. value = value;
}
public Biginteger getValue() {
return value;
}
public void setValue(Biglnteger value) {
this. value = value;
}
}
Obwohl normalerweise das doppelte Tagging erlaubt ist, sollte kein tatsächliches doppeltes Tagging erfolgen, wie beispielsweise, dass MyObject in einer anderen SEQUENCE nochmals getaggt wird. Insbesondere beim impliziten Tagging wird dann eine ASN1 - Exeption geworfen.
Häufig wird auf Grund von Speicherplatzmangel ein implizites Tagging angewendet. In diesem Fall wird der Universal-Tag des eigentlichen ASN1 -Objektes verschluckt. Dies spart mindestens zwei Bytes ein, wobei der Empfänger die ASN1 -Spezifikation des Objektes kennen sollte. Das implizite Tagging im ASN1 -Annotation-Framework funktioniert derart:
MyObject ::= [APPLICATION 0] INTEGER
@ASN1 Integer
@ASN1Tag(implicit = true, number = 0, type = ASNITagType.APPLICATION) public class MyObject extends DERRoot {
@ASN1TargetField
private Biginteger value;
} Wird das Attribut implicit auf true gesetzt, so wird an dieser Stelle mit einem impliziten Tag gearbeitet. Bei einem Wert value von 100 ist das Umwandlungsergebnis: 500164.
In gleicher weise kann bei SEQUENCE aus dem oberen Beispielen vorgegangen werden.
Die entsprechenden Felder können eine Enumeration sein. Die Enumeration sollte einen für den ASN1 -Typ gültigen Wert zurückgeben. Folgendes Beispiel zeigt die Verwendung von Enumerationen:
MyValues ::= INTEGER { value1 (1 ), value2(2) }
MyObject ::= MyValues
@ASN1 Integer
@ASN1 Enum(findMethod = "getEnum", innerType = int.class, getMethod = "getValue") public class MyObject extends DERRoot {
public enum MyValues {
VALUE1 (1 ),
VALUE2(2);
private int value;
MyValues(int value) {
this. value = value;
}
public int getValue() {
return value;
}
public static MyValues getEnum(int value) {
for (MyValues e : values()) {
if (e.getValue() == value) {
return e;
}
}
throw new IHegalArgumentException("no enum found for: " + value);
}
}
@ASN1TargetField
private MyValues value;
public MyValues getValueQ { return value;
}
public void setValue(MyValues value) {
this. value = value;
}
}
Im angeführten Beispiel ist zu erkennen, dass die Enumeration zwei Methoden umfasst: Die Methode getValue zum Ermitteln des tatsächlichen Enumeration-Wertes und die Methode getEnum zum Ermitteln der tatsächlichen Enumeration-Konstante über den Wert. Diese beiden Methoden werden in der Annotation ASNIEnum gesetzt. Das Attribut findMethod verlangt eine Methode, die den erwarteten Wert annimmt und versucht diesen in eine Enumeration-Konstante zurückzuführen. Das Attribut getMethod verlangt hingegen eine Methode, die einen tatsächlichen gültigen Wert zurückgibt, der durch die gesetzte
Enumeration-Konstante gegeben ist. Diese Annotation kann für ein Feld, beispielsweise innerhalb von SEQUENCE, verwendet werden.
Bit-Strings werden in der Regel verwendet, um den Zustand von mehreren Flags zu speichern. Dabei wird jedes Flag vom Typ boolean, das entweder gesetzt oder nicht gesetzt sein kann, in diesen Bit-String eingesetzt. Dies ist im ASN1 -Annotation-Framework wie folgt zu implementieren:
MyObject ::= BIT STRING (
valuel (0),
value2 (1 ))
@ASN1 ComplexBitString
public class MyObject extends DERRoot {
@ASN1 BitStringBit(bitPosition = 0)
private boolean valuel ;
@ASN1 BitStringBit(bitPosition = 1 )
private boolean value2;
@Override
public void validate() {
}
* @return the valuel
7 public boolean isValuel () {
return valuel ;
}
* @param valuel the valuel to SET
7
public void setValuel (boolean valuel ) {
this. valuel = valuel ;
}
* @return the value2
7
public boolean isValue2() {
return value2;
}
* @param value2 the value2 to set
7
public void setValue2(boolean value2) {
this.value2 = value2;
}
}
In diesem Beispiel werden die einzelnen Bits durch boolesche Parameter dargestellt. Wenn der ASN1 -Bytecode erzeugt wird, so wird ein Bytearray von ausreichender Länge erzeugt. Die nicht verwendeten Bytes werden als unusedbits markiert. Diese Berechnung kann über das Attribut calculateBitsPadding abgeschaltet werden. Sollte dieses Attribut auf false stehen, so wird unusedbits auf 0 gesetzt.
Vorteilhaft ist es, eine Basis für ein ASN1 -Objekt zu besitzen. Daher bietet das ASN1 - Annotation-Framework eine Möglichkeit, um die Vererbung zu verwenden. Diese kann auch über mehrere Klassen hinweg erfolgen. Der Basis-Typ eines Feldes kann zwar ein Interface oder eine abstrakte Klasse sein, jedoch sind die Annotationen ausschließlich an abstrakten Klassen oder dem Feld-Interface angeordnet, nicht jedoch an vererbten, darüber liegenden Interfaces. Dies wird durch die Mehrfachvererbung von Interfaces verhindert. Im folgenden Beispiel ist eine einfache Vererbung dargestellt. Dabei wird als Basis ein Interface (Schnittstelle) verwendet, das die konkreten Klassen implementiert:
@ASN1Abstract(implementors = {
MyObject. class
})
public interface Mylnterface extends DERInterface {
void setValue(int value);
int getValue();
}
@ASN1 Integer
public class MyObject extends DERRoot implements Mylnterface {
@ASN1TargetField
private int value;
public MyObject() {
super();
}
public MyObject(int value) {
this. value = value;
}
}
@ASN1 SEQUENCE
public class MySEQUENCE extends DERRoot {
@ASN1 Complex
@ASN1 SEQUENCEField(position = 1 )
private Mylnterface value;
public Mylnterface getValue() {
return value;
}
public void setValue(Mylnterface value) {
this. value = value;
}
} My Interface obj = new MyObject();
obj.setValue(100);
MySEQUENCE seq = new MySEQUENCE();
seq.setValue(obj);
Hierzu wird ein Interface (Schnittstelle) deklariert, das die benötigten Get-Methoden (Getter) und Set-Methoden (Setter) bereitstellt. Zusätzlich sollte das Interface von der Klasse DERInterface erben. Damit wird sichergestellt, dass das Objekt tatsächlich ein ASN1 -Objekt ist. Die Klasse DERRoot implementiert dieses Interface. Alle Klassen, die das deklarierte Interface implementieren, werden dort mittels der Annotation ASN1Abstract \m Attribut implementors in einer Liste gelistet. Dadurch erkennt der Parser, welche Klassen er berücksichtigen soll.
Die geerbten Objekte sollten eindeutig zuzuordnen sein, da ansonsten eine Ausnahme ASN1-Exception geworfen wird. Um dem Abhilfe zu schaffen, kann die Eindeutigkeit über einen Identifier (Identifikator) gewährleistet werden.
Bei der komplexen Vererbung von ASN1 -Klassen ist eine Struktur eines abstrakten Objektes nur oberflächlich bekannt. Das folgende Beispiel verdeutlicht dies:
MyBase CLASS ::= {
&value INTEGER,
&Type
}
MyAbstractObject {MyBase} ::= SEQUENCE {
valuel MyBase. &value,
value2 MyBase.&Type({@value1 })
MyObject ::= MyAbstractObject{1 , UTF8String}
@ASN1 SEQUENCE
@ASN1Abstract(implementors = {
MyObject.class,
})
public abstract class MyAbstractObject<T> extends DERRoot {
@ASN1 Integer
@ASN1 SEQUENCEField(position = 1 ) private Integer valuel ;
@ASN1 SEQUENCEField(position = 2)
protected T value2;
protected Integer getValuel () {
return valuel ;
}
protected void setValuel (Integer valuel ) {
this. valuel = valuel ;
}
}
public class MyObject extends MyAbstractObject<String> {
public MyObject() {
setValuel (1 );
}
@ASN1 UTF8String
public String getValue2() {
return value2;
}
public void setValue2(String value2) {
this.value2 = value2;
}
}
Hier ist zu erkennen, in welcher Weise die Basis als SEQUENCE markiert wird. Hierzu werden die bereits bekannten Felder valuel und value2 mit einer S£QL/£/VC£-Position versehen. Eine Besonderheit ist die Variable value2, deren Typ noch unbekannt ist und erst in der implementierenden Klasse an der Get-Methode des Feldes gesetzt wird. Das Feld sollte protected sein oder die Get-Methode sollte protected und überschreibbar sein.
An vielen Stellen wird allerdings mit einer sogenannten Set-Methode gearbeitet. Diese Strukturen lassen sich eleganter als das obige Beispiel schreiben:
MyClass ::= CLASS {
&id INTEGER
&Type
} mylntegerClass MyClass ::= {{1 , INTEGER}} myStringClass MyClass ::= {{2, UTF8String}}
MyClassTable ::= {
mylntegerClass,
myStringClass
}
MyObject {MyClass: MyClassTable} ::= SEQUENCE { protocol MyClass. &id,
value MyClass. &Type,
comment PrintableString
}
@ASN10bjectClass
public class MyClass {
@ASN1 Integer
private int id;
@ASN10penType
private AnnotationType<?> type; public MyClass(int id, AnnotationType type) { this.id = id;
this.type = type;
}
public int getld() {
return id;
}
public void setld(int id) {
this.id = id;
}
public AnnotationType<?> getType() {
return type;
}
public void setType(AnnotationType<?> type) { this.type = type;
}
}
@ASN10bjectSET(baseObjectClass = MyClass.class) public class MyClassTable {
public static final MyClass mylntegerClass = new MyClass(1 , new
ASN1 lntegerType());
public static final MyClass myStringClass = new MyClass(2, new
ASN1 UTF8StringType());
}
@ASN1 SEQUENCE
@ASN1 UseObjectSET(MyClassTable. class)
@ASN1Abstract(implementors = {MyObjectJnteger.class, MyObject_String. class}) public abstract class MyObject<T> extends DERRoot {
@ASN1 SEQUENCEField(position = 1 )
@ASN 10bjectClassl DReference("id")
private int protocol;
@ASN1 SEQUENCEField(position = 2)
@ASN10bjectClassTypeReference("type")
private T value;
@ASN1 SEQUENCEField(position = 3)
@ASN1 PrintableString
private String comment;
public T getValue() {
return value;
}
public void setValue(T value) {
this. value = value;
}
public String getComment() {
return comment;
}
public void setComment(String comment) {
this.comment= comment;
}
}
@ASN10bjectSetValue("MylntegerClass")
public class MyObjectJnteger extends ASN1 AbstractTestObjectWithSET<lnteger> { }
@ASN10bjectSetValue("MyStringClass") public class MyObject_String extends ASN1AbstractTestObjectWithSET<String> { }
Hier werden alle aus dem Skript bekannten Objekte verwendet. Die Klasse dient der Beschreibung des Typs mittels einer ID, das Feld protocol wird auf id gemappt und das Feld value wird auf den ASN1 -Typ gemappt, der abhängig von der Identifikation ID ist.
Dementsprechend existiert eine Ableitung für den Fall Integer und eine für den Fall String.
Diese werden mit der Annotation ASN1 ObjectSetValue versehen, die beschreibt, welcher ObjectSetValue verwendet werden soll. Diese Angabe sollte sich mit den Annotation-Werten der Super-Klasse decken.
Um den Typen anzugeben, wird dieser mit der Annotation ASNIOpenType markiert, der zudem vom Typ AnnotationType ist. AnnotationType ist ein Typ, der eine Annotation repräsentiert. Beispielsweise ist ein ASNIIntegerType die Repräsentation der ASNIInteger- Annotation. Der Typ kann einfach mittels der Methode toAnnotation in eine gültige
Annotation umgewandelt werden. Innerhalb des Frameworks werden diese Typen verwendet, um bei einer ASN1 -Klassendefinition den ASN1 -Typen als Typ mitzugeben. Den ASN1 -Annotation-Typen können aber auch die gesamten Attribute der bekannten ASN1 - Typ-Annotationen über den Konstruktor oder über Set-Methoden mitgegeben werden.
Manchmal werden im Rahmen der komplexen Vererbung Identifier vergeben, die ein Objekt eindeutig kennzeichnen. Dies zeigt folgendes Beispiel:
@ASN1 SEQUENCE
@ASN1Abstract(implementors = {
DERChipAuthenticationlnfo. class,
DERTerminalAuthenticationlnfo. class,
DERChipAuthenticationPublicKeylnfo. class
})
public abstract class DERSecuritylnfo<Required, Optional> extends DERRoot { @ASN10bjectldentifier
@ASN1 SEQUENCEField(position = 0)
@ASN1 ldentifier(matchMethod = "isMatch")
protected DERObjectldentifier protocolOID;
//Type definition in child Implementation @ASN1 SEQUENCEField(position = 1 )
private Required required;
//Type definition in child Implementation
@ASN1 SEQUENCEField(position = 2, optional = ASN I Optional.NotNull) private Optional optional;
@Override
public void validate() {
if (protocolOID == null)
throw new SecuritylnfoValidationException("Cannot create or parse
DERSecuritylnfo!",
ASN1 Validation Exception.createAIIMustNotNullException("protocolOID"));
}
protected DERSecuritylnfo() {
}
protected Required getRequired() {
return required;
}
protected void setRequired(Required required) {
this. required = required;
}
protected Optional getOptional() {
return optional;
}
protected void setOptional(Optional optional) {
this. optional = optional;
}
// Check the matching
protected abstract boolean isMatch(String id);
}
public class DERChipAuthenticationlnfo extends
DERSecuritylnfo<org.bouncycastle.asn1.ASN1 Integer, lnteger> {
public enum ChipAuthenticationProtocol {
CA_DH_3DES_CBC_CBC(BSIIdentifier.lD_CA_DH_3DES_CBC_CBC), CA_ECDH_3DES_CBC_CBC(BSIIdentifier.lD_CA_ECDH_3DES_CBC_CBC); public static ChipAuthenticationProtocol fromOID(String oid) {
for (ChipAuthenticationProtocol item : ChipAuthenticationProtocol. valuesQ) { if (item.getold().equals(oid))
return item;
}
throw new SecuritylnfoOtherException("Cannot find type for OID " + oid);
}
public static boolean checkOID(String oid) {
for (ChipAuthenticationProtocol item : ChipAuthenticationProtocol.values()) { if (item.getold().equals(oid))
return true;
}
return false;
}
private String oid;
private ChipAuthenticationProtocol(String oid) {
this.old = oid;
}
public String getold() {
return oid;
}
}
public DERChipAuthenticationlnfo() {
}
public DERChipAuthenticationlnfo(ChipAuthenticationProtocol protocol) { super();
this.protocolOID = new DERObjectldentifier(protocol.getold());
super.setOptional(null);
super.setRequired(new org.bouncycastle.asn1 .ASN1 lnteger(1 ));
}
public DERChipAuthenticationlnfo(ChipAuthenticationProtocol protocol, int keyld) { super();
this.protocolOID = new DERObjectldentifier(protocol.getold());
super.setOptional(keyld);
super.setRequired(new org.bouncycastle.asn1 .ASN1 lnteger(1 ));
}
public ChipAuthenticationProtocol getProtocol() {
return ChipAuthenticationProtocol.fromOID(this.protocolOID.getld()); }
public void setProtocol(ChipAuthenticationProtocol protocol) {
this.protocolOID = new DERObjectldentifier(protocol.getold());
}
public Integer getKeyld() {
return super.getOptional();
}
public void setKeyld(lnteger keyld) {
super.setOptional(keyld);
}
//Additional annotation for optional
@Override
©ASNI Integer
protected Integer getOptional() {
return super.getOptional();
}
//Additional annotation for required
@Override
©ASNI Integer
protected org.bouncycastle.asn1 .ASN1 Integer getRequired() {
return super.getRequired();
}
@Override
protected void setRequired(org.bouncycastle.asn1.ASN1 Integer derlnteger) { super.setRequired(derlnteger);
}
@Override
protected void setOptional(lnteger integer) {
super.setOptional(integer);
}
@Override
protected boolean isMatch(String id) {
return ChipAuthenticationProtocol.checkOID(id);
}
@Override public void validate() {
super.validate();
if (!super.getRequired().equals(new org.bouncycastle.asn1 .ASN1 lnteger(1 ))) { throw new SecuritylnfoValidationException("required should be 1 , but was: " + super.getRequired());
}
}
}
public class DERChipAuthenticationPublicKeylnfo extends
DERSecuritylnfo<DERSubjectPublicKeylnfo, lnteger> {
public enum ChipAuthenticationPublicKeyProtocol {
PK_DH(BSIIdentifier.lD_PK_DH), PK_ECDH(BSIIdentifier.lD_PK_ECDH); public static ChipAuthenticationPublicKeyProtocol fromOID(String oid) { for (ChipAuthenticationPublicKeyProtocol item :
ChipAuthenticationPublicKeyProtocol.valuesO) {
if (item.getold().equals(oid))
return item;
}
throw new SecuritylnfoOtherException("Cannot find type for OID " + oid);
}
public static boolean checkOID(String oid) {
for (ChipAuthenticationPublicKeyProtocol item :
ChipAuthenticationPublicKeyProtocol.valuesO) {
if (item.getold().equals(oid))
return true;
}
return false;
}
private String oid;
private ChipAuthenticationPublicKeyProtocol(String oid) {
this.old = oid;
}
public String getold() {
return oid;
} }
@Override
@ASN1 Complex
protected DERSubjectPublicKeylnfo getRequired() {
return super.getRequired(); //To change body of overridden methods use File | SETtings | File Templates.
}
@Override
protected void setRequired(DERSubjectPublicKeylnfo derSubjectPublicKeylnfo) { super.setRequired(derSubjectPublicKeylnfo); //To change body of overridden methods use File | SETtings | File Templates.
}
@Override
@ASN1 Integer
protected Integer getOptional() {
return super.getOptional(); //To change body of overridden methods use File | SETtings | File Templates.
}
@Override
protected void setOptional(lnteger integer) {
super.setOptional(integer); //To change body of overridden methods use File | Settings | File Templates.
}
public DERChipAuthenticationPublicKeylnfo() {
}
public DERChipAuthenticationPublicKeylnfo(ChipAuthenticationPublicKeyProtocol protocol,
DERSubjectPublicKeylnfo subjectPublicKeylnfo) {
super();
this.protocolOID = new DERObjectldentifier(protocol.getold());
super.setRequired(subjectPublicKeylnfo);
super.setOptional(null);
}
public DERChipAuthenticationPublicKeylnfo(ChipAuthenticationPublicKeyProtocol protocol,
DERSubjectPublicKeylnfo subjectPublicKeylnfo, int keyld) { super();
this.protocolOID = new DERObjectldentifier(protocol.getold());
super.setRequired(subjectPublicKeylnfo);
super.setOptional(keyld);
}
@Override
protected boolean isMatch(String id) {
return ChipAuthenticationPublicKeyProtocol.checkOID(id);
}
public ChipAuthenticationPublicKeyProtocol getProtocol() {
return ChipAuthenticationPublicKeyProtocol.fromOID(protocolOID.getld());
} public void setProtocol(ChipAuthenticationPublicKeyProtocol protocol) {
this.protocolOID = new DERObjectldentifier(protocol.getold());
}
public DERSubjectPublicKeylnfo getSubjectPublicKeylnfo() {
return super.getRequired();
}
public void setSubjectPublicKeylnfo(DERSubjectPublicKeylnfo subjectPublicKeylnfo)
{
super.setRequired(subjectPublicKeylnfo);
}
public Integer getKeyld() {
return super.getOptional();
}
public void setKeyld(lnteger keyld) {
super.setOptional(keyld);
}
}
public class DERTerminalAuthenticationlnfo extends
DERSecuritylnfo<org.bouncycastle.asn1.ASN1 Integer, DERFilelD> {
public enum TerminalAuthenticationProtocol {
TA(BSIIdentifier.lD_TA);
public static TerminalAuthenticationProtocol fromOID(String oid) {
for (TerminalAuthenticationProtocol item : TerminalAuthenticationProtocol. valuesQ) if (item.getold().equals(oid))
return item;
}
throw new SecuritylnfoOtherException("Cannot find type for OID " + oid);
}
public static boolean checkOID(String oid) {
for (TerminalAuthenticationProtocol item : TerminalAuthenticationProtocol. values()) if (item.getold().equals(oid))
return true;
} return false;
}
private String oid;
private TerminalAuthenticationProtocol(String oid) {
this.old = oid;
}
public String getold() {
return oid;
}
}
public DERTerminalAuthenticationlnfo(TerminalAuthenticationProtocol protocol) { this.protocolOID = new DERObjectldentifier(protocol.getold());
super.setOptional(null);
super.setRequired(new org.bouncycastle.asn1 .ASN1 lnteger(1 ));
}
public DERTerminalAuthenticationlnfo(TerminalAuthenticationProtocol protocol, DERFilelD fileld) {
super();
this.protocolOID = new DERObjectldentifier(protocol.getold());
super.setOptional(fileld);
super.setRequired(new org.bouncycastle.asn1 .ASN1 lnteger(1 ));
}
public TerminalAuthenticationProtocol getProtocolQ { return TerminalAuthenticationProtocol.fromOID(protocolOID.getld());
}
public void setProtocol(TerminalAuthenticationProtocol protocol) {
this.protocolOID = new DERObjectldentifier(protocol.getold());
}
public DERTerminalAuthenticationlnfo() {
}
@Override
protected boolean isMatch(String id) {
return TerminalAuthenticationProtocol.checkOID(id);
}
public DERFilelD getFileld() {
return super.getOptional();
}
public void setFileld(DERFilelD fileld) {
super.setOptional(fileld);
}
@Override
@ASN1 Integer
protected org.bouncycastle.asn1.ASN1 Integer getRequired() {
return super.getRequired();
}
@Override
protected void setRequired(org.bouncycastle.asn1.ASN1 Integer derlnteger) { super.setRequired(derlnteger);
}
@Override
@ASN1 Complex
protected DERFilelD getOptional() {
return super.getOptional(); //To change body of overridden methods use File | Settings | File Templates.
}
@Override
protected void setOptional(DERFilelD derFilelD) {
super.setOptional(derFilelD); //To change body of overridden methods use File | Settings | File Templates.
}
@Override
public void validate() {
super.validate();
if (!super.getRequired().equals(new org.bouncycastle.asn1.ASN1 lnteger(1 ))) { throw new SecuritylnfoValidationException("required should be 1 , but was: " + super.getRequired());
}
}
}
In diesem Beispiel ist zu erkennen, dass alle geerbten Klassen gleich aufgebaut sind und faktisch keine Eindeutigkeit mehr existiert. Dies wird behoben, indem die Annotation ASNIIdentifier verwendet wird, um das Objekt eindeutig zu identifizieren und damit eine Prüfung auf das markierte Feld erfolgen kann. Mit dem Attribut matchMethod wird eine Methode festgelegt, die überprüft, ob die angegebenen Eingangsdaten zu dem Objekt passen. Damit wird die Eindeutigkeit des Objektes gewahrt.
Manchmal werden in einer ASN1 -Struktur keine Angaben über weitere Elemente beispielsweise innerhalb von SEQUENCE gemacht. Im folgenden Beispiel wird eine solche ASN1 -Future-Extension-Deklaration durchgeführt:
MyObject ::= SEQUENCE {
valuel INTEGER,
}
@ASN1 SEQUENCE
public class MyObject extends DERRoot {
@ASN1 Integer
@ASN1 SEQUENCEField(position = 0)
private int valuel ;
@ASN1 FutureExtension(createMethod = "create", parseMethod = "_parse")
@ASN1 SEQUENCEField(position = 1 )
private List<lnteger> value2 = new ArrayList<lnteger>();
protected DEREncodable[] create(Object value) throws lOException { DEREncodable[] result = new DEREncodable[value2.size()];
for (int i = 0; i < result. length; i++) {
result[i] = new DERApplicationSpecific(false, 0x2E, new DERInteger(value2.get(i)));
}
return result;
}
protected void _parse(DEREncodable encodable) throws lOException {
if (!(encodable instanceof DERApplicationSpecific))
throw new ASN1 ParseException("Cannot parse object! Must be an integer!");
DERApplicationSpecific app = (DERApplicationSpecific) encodable;
if (app.getApplicationTagO != 0x2E)
throw new ASN1 ParseException("Wrong application number!");
this.add(((DERInteger)
app.getObject(ASN10bject.lNTEGER)).getValue().intValue());
}
public void add(int i) {
value2.add(i);
valuel = value2.size();
}
public void remove(int i) {
value2.remove((Object) i);
valuel = value2.size();
}
public int get(int index) {
return value2.get(index);
}
}
Bei der FyfyreExfens/on-Annotation wird sowohl die create- als auch die parse-Methode über die Attribute createMethod oder parseMethod angegeben. In diesen Methoden findet die eigentliche Umwandlung gemäß ASN1 oder die Umwandlung in Datentypen statt. Dabei wird die im obigen Beispiel aufgeführte Methodensignatur bis auf die Methodennamen identisch übernommen. Bei dem FutureExtension-Typ wlrd keine Tag-Annotation
angegeben. Der Tag wird, wie im obigen Beispiel, davorgehängt. Alle in der ASN1 -Sprache existierenden Constraints können bei Bedarf über die
Annotationen mit angegeben werden.
Fig. 8 zeigt dazu die möglichen Annotationen durch das Framework. Folgendes Beispiel verdeutlicht die Anwendung dieser Vorgehensweise: MyObject ::= INTEGER(0..10)
@ASN1 lnteger(valueRangeConstraint = @ASN1ValueRangeConstraint(minimum = 1 , maximum = 10))
public class MyObject extends DERRoot {
@ASN1TargetField
private Biginteger value;
}
Sollte die Integer-Variable außerhalb der Wertebereiche liegen, so wird eine
ASN1 ValidationException geworfen.
Constraints (Beschränkungen) können über mehrere Objekte hinweg neu gesetzt werden. Dies spielt bei der Vererbung von Klassen eine Rolle. Folgendes Beispiel verdeutlicht die Vorgehensweise:
MyAbstractObject ::= UTF8String FROM("A".."Z");
MyBaseObject ::= MyAbstractObject SIZE(5..10);
MyObject ::= [APPLICATION 10] MyBaseObject;
@ASN1 UTF8String(patternConstraint = @ASN1 PatternConstraint("[A-Z]*")) public abstract class MyAbstractObject extends DERRoot {
@ASN1TargetField
private String value;
}
@ASN1 Constraint(sizeConstraint = @ASN1 SizeConstraint(minimum = 5, maximum = 10))
public class MyBaseObject extends MyAbstractObject {
} @ASN1 Tag(type = ASNI TagType.Application, number = 10)
public final class MyObject extends MyBaseObject {
}
Hier werden über mehrere Klassengenerationen unterschiedliche Constraints zusätzlich den einzelnen Kind-Klassen zugeordnet. Dadurch können Constraints von Generation zu Generation angereichert werden. Beim Überschreiben von Constraints wird in jedem Fall eine ASN1 -Exception geworfen.
Constraints können aber auch in Klassen angewendet werden:
MyClass ::= CLASS {
&id INTEGER
&Type
}
MylntegerClass MyClass ::= {1 , INTEGER(0..10)}
MyStringClass MyClass ::= {2, UTF8String SIZE(20..40)}
MyClassTable ::= {
MylntegerClass,
MyStringClass
}
MyObject {MyClass:MyClassTable} ::= SEQUENCE {
protocol MyClass. &id,
value MyClass. &Type,
comment PrintableString
}
@ASN10bjectClass
public class MyClass {
@ASN1 Integer
private int id;
@ASN10penType
private AnnotationType<?> type;
public MyClass(int id, AnnotationType type) {
this.id = id;
this.type = type;
} public int getld() {
return id;
}
public void setld(int id) {
this.id = id;
}
public AnnotationType<?> getType() {
return type;
} public void setType(AnnotationType<?> type) {
this.type = type;
}
}
@ASN10bjectSET(baseObjectClass = MyClass.class)
public class MyClassTable {
public static final MyClass mylntegerClass;
public static final MyClass myStringClass;
static {
ASN1 IntegerType integerType = new ASN1 lntegerType();
integerType.setValueRangeConstraint(new ASN1ValueRangeConstraintType(0, 10));
ASN1 UTF8StringType utf8Type = new ASN1 UTF8StringType();
utf8Type.setSizeConstraint(new ASN 1 SizeConstraintType(20, 40));
mylntegerClass = new MyClass(1 , integerType);
myStringClass = new MyClass(2, utf8Type);
}
}
@ASN1 SEQUENCE
@ASN1 UseObjectSET(MyClassTable. class)
@ASN1Abstract(implementors = {MyObject_lnteger.class, MyObject_String. class}) public abstract class MyObject<T> extends DERRoot {
@ASN1 SEQUENCEField(position = 1 )
@ASN10bjectClasslDReference("id")
private int protocol; @ASN1 SEQUENCEField(position = 2)
@ASN10bjectClassTypeReference("type")
private T value;
@ASN1 SEQUENCEField(position = 3)
@ASN1 PrintableString
private String comment;
public T getValue() {
return value;
}
public void setValue(T value) {
this. value = value;
} public String getComment() {
return comment;
}
public void setComment(String comment) {
this.comment= comment;
}
}
@ASN10bjectSETValue("MylntegerClass")
public class MyObjectJnteger extends ASN1 AbstractTestObjectWithset<lnteger> { }
@ASN10bjectSETValue("MyStringClass")
public class MyObject_String extends ASN1AbstractTestObjectWithSET<String> { }
In diesem Beispiel wird eine typenspezifische Constraint-Auspragung innerhalb der ASN1 - Klassen verwendet.
Alle in Verbindung mit einzelnen Ausführungsformen der Erfindung erläuterten Merkmale können in unterschiedlicher Kombination in dem erfindungsgemäßen Gegenstand vorgesehen sein, um gleichzeitig deren vorteilhafte Wirkungen zu realisieren. Der Schutzbereich der vorliegenden Erfindung ist durch die Ansprüche gegeben und wird durch die in der Beschreibung erläuterten oder die in den Figuren gezeigten Merkmale nicht beschränkt.
BEZUGSZEICHENLISTE
Ausgangsdaten
Zieldaten
Annotations
AS N 1 - F ra m ewo rk/ U mwa n d I er
Funktionsaufruf
Verfahrensschritte
ASN1 -Frameworks
Handler
Handler
ASNI Encodable
DERRoot
DERinterface
CreationUtility
ParsingUtility
ASNI XXXParsingHandler
ASN1 Abstract Simple Type
Interface
ASN 1 Handler
convert Object
ASN1 Abstract Simple Type
ASN 1 Creation Handler
sd ASN1 Simple Creation
Creation Root Handler
Creation Utility
Verfahrenschritt
Verfahrenschritt Verfahrenschritt
Verfahrenschritt
sd ASN1 Complex Creation
Sequence Handler
Verfahrenschritt
Verfahrenschritt
Verfahrenschritt
Verfahrenschritt
Verfahrenschritt
Verfahrenschritt
Verfahrenschritt
act ASN1
Finde ASN1 -Type-Annotation
Handle einfachen Typ
Handle Sequences/Sets
Finde alle Felder mit ASN1 -Type-Annotation
Abfrage
Creation/Parsing
Handle SEQ-UENCEO
Handle einfachen Typ
Abfrage
Abfrage
Ende
Ende

Claims

PATENTANSPRÜCHE
1 . Verfahren zum Umwandeln von Ausgangsdaten (100) in Zieldaten (101 ) gemäß ASN.1 , mit den Schritten:
Einlesen (S102) zumindest einer digitalen Umwandlungsanweisung (103) zum Umwandeln der Ausgangsdaten (100) in einem ersten Datenformat in die Zieldaten (101 ) in einem zweiten Datenformat; und
Erzeugen (S103) der Zieldaten (101 ) aus den Ausgangsdaten (100) gemäß der Umwandlungsanweisung (103).
2. Verfahren nach Anspruch 1 , wobei die Umwandlungsanweisung (103) in einem Quellcode vorgesehen ist.
3. Verfahren nach Anspruch 2, wobei der Quellcode eine Klassendefinition ist.
4. Verfahren nach Anspruch 2 oder 3, weiter mit dem Schritt eines Parsens des Quellcodes zum Einlesen der Umwandlungsanweisung (103).
5. Verfahren nach einem der vorangehenden Ansprüche, mit dem Schritt eines Aufrufens eines Umwandlers (105) zum Einlesen der Umwandlungsanweisung (103) und Erzeugen der Zieldaten (101 ).
6. Verfahren nach Anspruch 5, weiter mit dem Schritt eines Steuerns des Umwandlers (105) über die Umwandlungsanweisung (103).
7. Verfahren nach Anspruch 5, weiter mit dem Schritt eines Aufrufens (S 101 ) des Umwandlers (105) über ein Objekt.
8. Verfahren nach Anspruch 7, weiter mit dem Schritt eines Auslesens der
Umwandlungsanweisung (103) aus einer Klassendefinition des aufrufenden Objektes.
9. Verfahren nach Anspruch 7 oder 8, weiter mit dem Schritt eines Erzeugens der Zieldaten (101 ) aus Objektdaten.
10. Verfahren nach einem der Ansprüche 7 bis 9, weiter mit dem Schritt eines
Zurückgebens (S104) der Zieldaten (101 ) über das aufrufende Objekt.
1 1 . Verfahren nach einem der vorangehenden Ansprüche, wobei die Zieldaten (101 ) eine ASN.1 -Sequenz formen.
12. Verfahren nach Anspruch 1 1 , weiter mit dem Schritt eines Ausgebens der ASN.1 - Sequenz an ein Datennetzwerk.
13. Verfahren nach einem der vorangehenden Ansprüche, weiter mit dem Schritt eines Abbildens je einer Umwandlungsanweisung auf je einen Datentyp der Ausgangsdaten.
14. Umwandler (200) zum Umwandeln von Ausgangsdaten (100) in Zieldaten (101 ) gemäß ASN.1 , mit: einer Einlesevorrichtung (201 ) zum Einlesen zumindest einer digitalen
Umwandlungsanweisung (103) zum Umwandeln der Ausgangsdaten (100) in einem ersten Datenformat in die Zieldaten (101 ) in einem zweiten Datenformat; und einer Erzeugungsvorrichtung (203) zum Erzeugen der Zieldaten (101 ) aus den
Ausgangsdaten (100) gemäß der Umwandlungsanweisung (103).
15. Computerprogrammprodukt, das direkt in den internen Speicher eines digitalen Computers geladen werden kann und Softwarecodeabschnitte umfasst, mit denen das Verfahren nach einem der Ansprüche 1 bis 13 ausgeführt wird, wenn das Produkt auf einem Computer läuft.
EP13728708.2A 2012-06-08 2013-06-06 VERFAHREN ZUM UMWANDELN VON AUSGANGSDATEN IN ZIELDATEN GEMÄß ASN.1 Ceased EP2859701A1 (de)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
DE102012209674A DE102012209674A1 (de) 2012-06-08 2012-06-08 Verfahren zum Umwandeln von Ausgangsdaten in Zieldaten gemäß ASN.1
PCT/EP2013/061667 WO2013182634A1 (de) 2012-06-08 2013-06-06 VERFAHREN ZUM UMWANDELN VON AUSGANGSDATEN IN ZIELDATEN GEMÄß ASN.1

Publications (1)

Publication Number Publication Date
EP2859701A1 true EP2859701A1 (de) 2015-04-15

Family

ID=48626012

Family Applications (1)

Application Number Title Priority Date Filing Date
EP13728708.2A Ceased EP2859701A1 (de) 2012-06-08 2013-06-06 VERFAHREN ZUM UMWANDELN VON AUSGANGSDATEN IN ZIELDATEN GEMÄß ASN.1

Country Status (3)

Country Link
EP (1) EP2859701A1 (de)
DE (1) DE102012209674A1 (de)
WO (1) WO2013182634A1 (de)

Families Citing this family (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN109635032B (zh) * 2018-12-24 2023-07-28 福建凯米网络科技有限公司 一种数据转换的方法及终端
CN110737436B (zh) * 2019-09-05 2024-07-02 深圳平安通信科技有限公司 转码方法、装置及计算机可读存储介质

Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6915324B1 (en) * 2000-04-21 2005-07-05 Sun Microsystems, Inc. Generic and dynamic mapping of abstract syntax notation (ASN1) to and from interface definition language for network management

Family Cites Families (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0520708B1 (de) * 1991-06-28 1998-07-29 Digital Equipment Corporation Verfahren und Gerät zum Umwandlen von abstrakten Syntaxen auf hohem Niveau in eine Zwischenform
EP2139193B1 (de) * 2008-06-26 2012-10-17 TELEFONAKTIEBOLAGET LM ERICSSON (publ) Verfahren zur Durchführung von Datenvermittlung und entsprechendes Computerprogrammprodukt, Datenvermittlungsvorrichtung und Informationssystem

Patent Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6915324B1 (en) * 2000-04-21 2005-07-05 Sun Microsystems, Inc. Generic and dynamic mapping of abstract syntax notation (ASN1) to and from interface definition language for network management

Non-Patent Citations (3)

* Cited by examiner, † Cited by third party
Title
ANONYMOUS: "Polymorphism (computer science) - Wikipedia, the free encyclopedia", 24 May 2012 (2012-05-24), XP055408304, Retrieved from the Internet <URL:https://web.archive.org/web/20120524005708/https://en.wikipedia.org/wiki/Polymorphism_(computer_science)> [retrieved on 20170920] *
GERVASI VINCENZO ET AL: "Software Manipulation with Annotations in Java", 8 July 2007, ECCV 2016 CONFERENCE; [LECTURE NOTES IN COMPUTER SCIENCE; LECT.NOTES COMPUTER], SPRINGER INTERNATIONAL PUBLISHING, CHAM, PAGE(S) 161 - 184, ISBN: 978-3-642-33485-6, ISSN: 0302-9743, XP047428153 *
See also references of WO2013182634A1 *

Also Published As

Publication number Publication date
DE102012209674A1 (de) 2013-12-12
WO2013182634A1 (de) 2013-12-12

Similar Documents

Publication Publication Date Title
DE69615978T2 (de) Verfahren und Vorrichtung zum Verpackung und Entpackung von Daten in objectreferenzspezifischen Datenformaten anhand generischen Stubs
DE69731614T2 (de) Netzübergreifende einrichtung und verfahren zur herstellung einer solchen einrichtung
DE60011479T2 (de) Xml-roboter
DE69331440T2 (de) Verfahren und system zur durchführung von fernprozeduranrufen in einem verteilten rechnersystem.
DE69609516T2 (de) Verfahren zur verwaltung dynamischer relationen zwischen objekten in dynamisch objektorientierten programmiersprachen
DE69727933T2 (de) Verfahren und gerät zum beschreiben einer definierten schnittstelle, einer operation und eines datentyps in einer schnittstellendefinitionssprache
DE69309485T2 (de) Verfahren zur verteilung von schnittstellenzeigern fur fernprozeduranrufe
DE69921474T2 (de) Methode-referenzierung in objektbasierter programmierung
DE69622144T2 (de) Allgemeines Fernprozeduraufrufsystem und allgemeines Fernprozeduraufrufverfahren
DE69525706T2 (de) Vorrichtung und Verfahren zum Generieren des Zielsprachcodes durch Verwendung eines objektorientierten Codegenerators
DE60224926T2 (de) Verfahren und Rechnersystem zur Behandlung von inkrementalen Daten in Klient-Server Kommunikation.
DE69931540T2 (de) Fernprozeduraufrufe mit Um- und Rückwandlung von beliebigen, nicht-übereinstimmenden Zeigergrössen
DE202014010938U1 (de) Omega-Namen: Namenserzeugung und -ableitung
DE60122671T2 (de) Anforderungsbedingte dynamische Schnittstellengenerierung
DE102012001406A1 (de) Automatische Konfiguration eines Produktdatenmanagementsystems
DE102021116315A1 (de) Verfahren zum Zusammenführen von Architekturinformationen
EP2859701A1 (de) VERFAHREN ZUM UMWANDELN VON AUSGANGSDATEN IN ZIELDATEN GEMÄß ASN.1
CN108509187A (zh) 一种自动生成软件平台mib功能代码的方法及系统
WO2023138890A1 (de) Datenverarbeitungseinrichtung und verfahren zum umwandeln von daten
DE69829854T2 (de) Verfahren und Gerät zur Erzeugung virtueller Szenen
EP1719345B1 (de) Verfahren und vorrichtung zur codierung und decodierung von strukturierten dokumenten
EP3213266A1 (de) Verfahren zur integration einer semantischen datenverarbeitung
DE10110039A1 (de) Ein Verfahren zur generischen Beschreibung und Manipulation beliebiger Datenstrukturen
DE102004039633B4 (de) Verfahren und Vorrichtung zum Austauschen fahrzeugoriginärer Informationen
EP1202166A1 (de) System zur Verifikation von Software-Anwendungsmodellen in Ketten von Software-Entwurfswerkzeugen

Legal Events

Date Code Title Description
PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

17P Request for examination filed

Effective date: 20141230

AK Designated contracting states

Kind code of ref document: A1

Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MK MT NL NO PL PT RO RS SE SI SK SM TR

AX Request for extension of the european patent

Extension state: BA ME

DAX Request for extension of the european patent (deleted)
STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: EXAMINATION IS IN PROGRESS

17Q First examination report despatched

Effective date: 20161221

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE APPLICATION HAS BEEN REFUSED

REG Reference to a national code

Ref country code: DE

Ref legal event code: R003

18R Application refused

Effective date: 20180921

P01 Opt-out of the competence of the unified patent court (upc) registered

Effective date: 20230526