DESBlock

Instance Constructors

new DESBlock(g: DESBlockGenerics = DESBlockGenerics())

Type Members

case class PrePopTask extends Product with Serializable

Definition Classes
Component
type RefOwnerType = Component

Definition Classes
Component → OwnableRef

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def addPrePopTask(task: () ⇒ Unit): ArrayBuffer[PrePopTask]

Definition Classes
Component
final def asInstanceOf[T0]: T0

Definition Classes
Any
val children: ArrayBuffer[Component]

Definition Classes
Component
val clockDomain: ClockDomain

Definition Classes
Component
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val cmdReady: Bool

Update the output
val ctnRound: Area { val round: spinal.core.UInt }

Count the number of round
Count the number of round
- Encryption 0 -> 15
- Decryption 16 -> 1
var definitionName: String

Definition Classes
Component
def delayedInit(body: ⇒ Unit): Unit

Definition Classes
Component → DelayedInit
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val feistelNetwork: Area { ... /* 2 definitions in type refinement */ }

Feistel network
Feistel network
| Li-1 | Ri-1 | (2 x 32 bits) (inBlock) -------------------------------- | | XOR<---(Des function)--| | \|_ Ki | | \ / \_/_ / \ -------------------------------- | Li | Ri | (2 x 32 bits) (outBlock) --------------------------------
val finalBlockPermutation: Area { val perm: spinal.core.Bits }

Final Permutation of the Block ( swap outBlock in order to have the same feistel network for each round )
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def forEachNameables(doThat: (Any) ⇒ Unit): Unit

Definition Classes
Nameable
val funcDES: Area { ... /* 5 definitions in type refinement */ }

DES function In 32 bits | --------------------- | Expansion | (32 -> 48bits) --------------------- | XOR <--------------- Ki (48 bits) | ---- --- --- | S1 |-| S2 |-...-| S8 | (sBox) ---- --- --- | (32 bits) ---------------------- | Permutation | ---------------------- | Out 32 bits
val gIO: SymmetricCryptoBlockGeneric
def getAllIo: Set[BaseType]

Definition Classes
Component
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getDisplayName(): String

Definition Classes
Component → Nameable
def getGroupedIO(ioBundleBypass: Boolean): Seq[Data]

Definition Classes
Component
def getName(): String

Definition Classes
NameableByComponent → Nameable
def getName(default: String): String

Definition Classes
Nameable
def getOrdredNodeIo: List[BaseType]

Definition Classes
Component
def getParentsPath(sep: String): String

Definition Classes
Component
def getPath(sep: String): String

Definition Classes
Component
def getRefOwnersChain(): List[Any]

Definition Classes
OwnableRef
def getScalaLocationLong: String

Definition Classes
ScalaLocated
def getScalaLocationShort: String

Definition Classes
ScalaLocated
val globalData: GlobalData

Definition Classes
GlobalDataUser
def hashCode(): Int

Definition Classes
AnyRef → Any
val init: Bool
val initialBlockPermutation: Area { val perm: spinal.core.Bits }

Initial permutation
val io: SymmetricCryptoBlockIO
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isNamed: Boolean

Definition Classes
Nameable
def isUnnamed: Boolean

Definition Classes
Nameable
val keyScheduling: Area { ... /* 3 definitions in type refinement */ }

Key scheduling For encryption : Key 64 bits | ----------------------- | Parity drop | (remove 8 bits => 56 bits) ----------------------- | | (2 x 28 bits) ------------ ------------ | Shift left | | Shift left | Round key Generator 1 ------------ ------------ | | | | !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | -------------- | !!! Shifting : 1 shift left for round 1,2,9,16, !!! K1 (48 bits) <--|--| compression | | !!! others rounds 2 shift left !!! | -------------- | !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ...
Key scheduling For encryption : Key 64 bits | ----------------------- | Parity drop | (remove 8 bits => 56 bits) ----------------------- | | (2 x 28 bits) ------------ ------------ | Shift left | | Shift left | Round key Generator 1 ------------ ------------ | | | | !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | -------------- | !!! Shifting : 1 shift left for round 1,2,9,16, !!! K1 (48 bits) <--|--| compression | | !!! others rounds 2 shift left !!! | -------------- | !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ... .... ... ------------ ------------ | Shift left | | Shift left | Round key Generator 16 ------------ ------------ | | -------------- K16 (48bits) <------| compression | --------------
For decryption : Replace the Shift left by a shift right
val lastRound: Bool
def nameElements(): Unit

Definition Classes
Component
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val nextRound: Bool
def noIoPrefix(): DESBlock.this.type

Definition Classes
Component
var nodes: ArrayBuffer[Node]

Definition Classes
Component
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val parent: Component

Definition Classes
Component
def parents(of: Component, list: List[Component]): List[Component]

Definition Classes
Component
def postPopEvent(): Unit

Definition Classes
Stackable
def postPushEvent(): Unit

Definition Classes
Component → Stackable
def prePopEvent(): Unit

Definition Classes
Component → Stackable
var refOwner: RefOwnerType

Definition Classes
OwnableRef
def rework[T](gen: ⇒ T): T

Definition Classes
Component
val roundNbr: UInt
val rspValid: Bool
def setCompositeName(nameable: Nameable, postfix: String, weak: Boolean): DESBlock.this.type

Definition Classes
Nameable
def setCompositeName(nameable: Nameable, postfix: String): DESBlock.this.type

Definition Classes
Nameable
def setCompositeName(nameable: Nameable, weak: Boolean): DESBlock.this.type

Definition Classes
Nameable
def setCompositeName(nameable: Nameable): DESBlock.this.type

Definition Classes
Nameable
def setDefinitionName(name: String): DESBlock.this.type

Definition Classes
Component
def setName(name: String, weak: Boolean): DESBlock.this.type

Definition Classes
Nameable
def setPartialName(name: String, weak: Boolean): DESBlock.this.type

Definition Classes
Nameable
def setPartialName(owner: Nameable, name: String, weak: Boolean): DESBlock.this.type

Definition Classes
Nameable
def setPartialName(name: String): DESBlock.this.type

Definition Classes
Nameable
def setPartialName(owner: Nameable, name: String): DESBlock.this.type

Definition Classes
Nameable
def setRefOwner(that: Any): Unit

Definition Classes
OwnableRef
def setWeakName(name: String): DESBlock.this.type

Definition Classes
Nameable
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
Nameable → AnyRef → Any
def unsetName(): Unit

Definition Classes
Nameable
val userCache: Map[AnyRef, Map[AnyRef, AnyRef]]

Definition Classes
Component
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object DESBlock | package symmetric

class DESBlock extends Component

Instance Constructors

new DESBlock(g: DESBlockGenerics = DESBlockGenerics())

Type Members

case class PrePopTask extends Product with Serializable

type RefOwnerType = Component

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addPrePopTask(task: () ⇒ Unit): ArrayBuffer[PrePopTask]

final def asInstanceOf[T0]: T0

val children: ArrayBuffer[Component]

val clockDomain: ClockDomain

def clone(): AnyRef

val cmdReady: Bool

val ctnRound: Area { val round: spinal.core.UInt }

var definitionName: String

def delayedInit(body: ⇒ Unit): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val feistelNetwork: Area { ... /* 2 definitions in type refinement */ }

val finalBlockPermutation: Area { val perm: spinal.core.Bits }

def finalize(): Unit

def forEachNameables(doThat: (Any) ⇒ Unit): Unit

val funcDES: Area { ... /* 5 definitions in type refinement */ }

val gIO: SymmetricCryptoBlockGeneric

def getAllIo: Set[BaseType]

final def getClass(): Class[_]

def getDisplayName(): String

def getGroupedIO(ioBundleBypass: Boolean): Seq[Data]

def getName(): String

def getName(default: String): String

def getOrdredNodeIo: List[BaseType]

def getParentsPath(sep: String): String

def getPath(sep: String): String

def getRefOwnersChain(): List[Any]

def getScalaLocationLong: String

def getScalaLocationShort: String

val globalData: GlobalData

def hashCode(): Int

val init: Bool

val initialBlockPermutation: Area { val perm: spinal.core.Bits }

val io: SymmetricCryptoBlockIO

final def isInstanceOf[T0]: Boolean

def isNamed: Boolean

def isUnnamed: Boolean

val keyScheduling: Area { ... /* 3 definitions in type refinement */ }

val lastRound: Bool

def nameElements(): Unit

final def ne(arg0: AnyRef): Boolean

val nextRound: Bool

def noIoPrefix(): DESBlock.this.type

var nodes: ArrayBuffer[Node]

final def notify(): Unit

final def notifyAll(): Unit

val parent: Component

def parents(of: Component, list: List[Component]): List[Component]

def postPopEvent(): Unit

def postPushEvent(): Unit

def prePopEvent(): Unit

var refOwner: RefOwnerType

def rework[T](gen: ⇒ T): T

val roundNbr: UInt

val rspValid: Bool

def setCompositeName(nameable: Nameable, postfix: String, weak: Boolean): DESBlock.this.type

def setCompositeName(nameable: Nameable, postfix: String): DESBlock.this.type

def setCompositeName(nameable: Nameable, weak: Boolean): DESBlock.this.type

def setCompositeName(nameable: Nameable): DESBlock.this.type

def setDefinitionName(name: String): DESBlock.this.type

def setName(name: String, weak: Boolean): DESBlock.this.type

def setPartialName(name: String, weak: Boolean): DESBlock.this.type

def setPartialName(owner: Nameable, name: String, weak: Boolean): DESBlock.this.type

def setPartialName(name: String): DESBlock.this.type

def setPartialName(owner: Nameable, name: String): DESBlock.this.type

def setRefOwner(that: Any): Unit

def setWeakName(name: String): DESBlock.this.type

final def synchronized[T0](arg0: ⇒ T0): T0