_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q6700
|
Count
|
train
|
func (m *MockCollector) Count() int {
ret := m.ctrl.Call(m, "Count")
ret0, _ := ret[0].(int)
return ret0
}
|
go
|
{
"resource": ""
}
|
q6701
|
Count
|
train
|
func (mr *MockCollectorMockRecorder) Count() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Count", reflect.TypeOf((*MockCollector)(nil).Count))
}
|
go
|
{
"resource": ""
}
|
q6702
|
GetAllRecords
|
train
|
func (m *MockCollector) GetAllRecords() map[string]*collector.FlowRecord {
ret := m.ctrl.Call(m, "GetAllRecords")
ret0, _ := ret[0].(map[string]*collector.FlowRecord)
return ret0
}
|
go
|
{
"resource": ""
}
|
q6703
|
GetAllDataPathPacketRecords
|
train
|
func (m *MockCollector) GetAllDataPathPacketRecords() []*collector.PacketReport {
ret := m.ctrl.Call(m, "GetAllDataPathPacketRecords")
ret0, _ := ret[0].([]*collector.PacketReport)
return ret0
}
|
go
|
{
"resource": ""
}
|
q6704
|
CollectUserEvent
|
train
|
func (mr *MockCollectorMockRecorder) CollectUserEvent(record interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectUserEvent", reflect.TypeOf((*MockCollector)(nil).CollectUserEvent), record)
}
|
go
|
{
"resource": ""
}
|
q6705
|
NewPortSpec
|
train
|
func NewPortSpec(min, max uint16, value interface{}) (*PortSpec, error) {
if min > max {
return nil, errors.New("Min port greater than max")
}
return &PortSpec{
Min: min,
Max: max,
value: value,
}, nil
}
|
go
|
{
"resource": ""
}
|
q6706
|
NewPortSpecFromString
|
train
|
func NewPortSpecFromString(ports string, value interface{}) (*PortSpec, error) {
var min, max int
var err error
if strings.Contains(ports, ":") {
portMinMax := strings.SplitN(ports, ":", 2)
if len(portMinMax) != 2 {
return nil, errors.New("Invalid port specification")
}
min, err = strconv.Atoi(portMinMax[0])
if err != nil || min < 0 {
return nil, errors.New("Min is not a valid port")
}
max, err = strconv.Atoi(portMinMax[1])
if err != nil || max >= 65536 {
return nil, errors.New("Max is not a valid port")
}
} else {
min, err = strconv.Atoi(ports)
if err != nil || min >= 65536 || min < 0 {
return nil, errors.New("Port is larger than 2^16 or invalid port")
}
max = min
}
return NewPortSpec(uint16(min), uint16(max), value)
}
|
go
|
{
"resource": ""
}
|
q6707
|
SinglePort
|
train
|
func (s *PortSpec) SinglePort() (uint16, error) {
if s.IsMultiPort() {
return 0, errors.New("Not a single port specification")
}
return s.Min, nil
}
|
go
|
{
"resource": ""
}
|
q6708
|
String
|
train
|
func (s *PortSpec) String() string {
if s.IsMultiPort() {
return strconv.Itoa(int(s.Min)) + ":" + strconv.Itoa(int(s.Max))
}
return strconv.Itoa(int(s.Min))
}
|
go
|
{
"resource": ""
}
|
q6709
|
Overlaps
|
train
|
func (s *PortSpec) Overlaps(p *PortSpec) bool {
a := p
b := s
if a.Min > b.Min {
a = s
b = p
}
if a.Max >= b.Min {
return true
}
return false
}
|
go
|
{
"resource": ""
}
|
q6710
|
IsIncluded
|
train
|
func (s *PortSpec) IsIncluded(port int) bool {
p := uint16(port)
if s.Min <= p && p <= s.Max {
return true
}
return false
}
|
go
|
{
"resource": ""
}
|
q6711
|
VerifyIPChecksum
|
train
|
func (p *Packet) VerifyIPChecksum() bool {
sum := p.computeIPChecksum()
return sum == p.ipHdr.ipChecksum
}
|
go
|
{
"resource": ""
}
|
q6712
|
UpdateIPChecksum
|
train
|
func (p *Packet) UpdateIPChecksum() {
p.ipHdr.ipChecksum = p.computeIPChecksum()
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
}
|
go
|
{
"resource": ""
}
|
q6713
|
VerifyTCPChecksum
|
train
|
func (p *Packet) VerifyTCPChecksum() bool {
sum := p.computeTCPChecksum()
return sum == p.tcpHdr.tcpChecksum
}
|
go
|
{
"resource": ""
}
|
q6714
|
UpdateTCPChecksum
|
train
|
func (p *Packet) UpdateTCPChecksum() {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
p.tcpHdr.tcpChecksum = p.computeTCPChecksum()
binary.BigEndian.PutUint16(buffer[tcpChecksumPos:tcpChecksumPos+2], p.tcpHdr.tcpChecksum)
}
|
go
|
{
"resource": ""
}
|
q6715
|
PacketToStringTCP
|
train
|
func (p *Packet) PacketToStringTCP() string {
var buf bytes.Buffer
buf.WriteString("(error)")
header, err := ipv4.ParseHeader(p.ipHdr.Buffer)
if err == nil {
buf.Reset()
buf.WriteString(header.String())
buf.WriteString(" srcport=")
buf.WriteString(strconv.Itoa(int(p.SourcePort())))
buf.WriteString(" dstport=")
buf.WriteString(strconv.Itoa(int(p.DestPort())))
buf.WriteString(" tcpcksum=")
buf.WriteString(fmt.Sprintf("0x%0x", p.tcpHdr.tcpChecksum))
buf.WriteString(" data")
buf.WriteString(hex.EncodeToString(p.GetTCPBytes()))
}
return buf.String()
}
|
go
|
{
"resource": ""
}
|
q6716
|
computeIPChecksum
|
train
|
func (p *Packet) computeIPChecksum() uint16 {
// IP packet checksum is computed with the checksum value set to zero
p.ipHdr.Buffer[ipv4ChecksumPos] = 0
p.ipHdr.Buffer[ipv4ChecksumPos+1] = 0
// Compute checksum, over IP header only
sum := checksum(p.ipHdr.Buffer[:p.ipHdr.ipHeaderLen])
// Restore the previous checksum (whether correct or not, as this function doesn't change it)
binary.BigEndian.PutUint16(p.ipHdr.Buffer[ipv4ChecksumPos:ipv4ChecksumPos+2], p.ipHdr.ipChecksum)
return sum
}
|
go
|
{
"resource": ""
}
|
q6717
|
computeTCPChecksum
|
train
|
func (p *Packet) computeTCPChecksum() uint16 {
var buf [2]byte
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
tcpBufSize := uint16(len(buffer) + len(p.tcpHdr.tcpData) + len(p.tcpHdr.tcpOptions))
oldCsumLow := buffer[tcpChecksumPos]
oldCsumHigh := buffer[tcpChecksumPos+1]
// Put 0 to calculate the checksum. We will reset it back after the checksum
buffer[tcpChecksumPos] = 0
buffer[tcpChecksumPos+1] = 0
csum := partialChecksum(0, p.ipHdr.Buffer[ipv4SourceAddrPos:ipv4SourceAddrPos+4])
csum = partialChecksum(csum, p.ipHdr.Buffer[ipv4DestAddrPos:ipv4DestAddrPos+4])
// reserved 0 byte
buf[0] = 0
// tcp option 6
buf[1] = 6
csum = partialChecksum(csum, buf[:])
binary.BigEndian.PutUint16(buf[:], tcpBufSize)
csum = partialChecksum(csum, buf[:])
csum = partialChecksum(csum, buffer)
csum = partialChecksum(csum, p.tcpHdr.tcpOptions)
csum = partialChecksum(csum, p.tcpHdr.tcpData)
csum16 := finalizeChecksum(csum)
// restore the checksum
buffer[tcpChecksumPos] = oldCsumLow
buffer[tcpChecksumPos+1] = oldCsumHigh
return csum16
}
|
go
|
{
"resource": ""
}
|
q6718
|
incCsum16
|
train
|
func incCsum16(start, old, new uint16) uint16 {
start = start ^ 0xffff
old = old ^ 0xffff
csum := uint32(start) + uint32(old) + uint32(new)
for (csum >> 16) > 0 {
csum = (csum & 0xffff) + ((csum >> 16) & 0xffff)
}
csum = csum ^ 0xffff
return uint16(csum)
}
|
go
|
{
"resource": ""
}
|
q6719
|
checksumDelta
|
train
|
func checksumDelta(init uint32, buf []byte) uint32 {
sum := init
for ; len(buf) >= 2; buf = buf[2:] {
sum += uint32(buf[0])<<8 | uint32(buf[1])
}
if len(buf) > 0 {
sum += uint32(buf[0]) << 8
}
return sum
}
|
go
|
{
"resource": ""
}
|
q6720
|
checksum
|
train
|
func checksum(buf []byte) uint16 {
sum32 := checksumDelta(0, buf)
sum16 := csumConvert32To16bit(sum32)
csum := ^sum16
return csum
}
|
go
|
{
"resource": ""
}
|
q6721
|
UpdateUDPChecksum
|
train
|
func (p *Packet) UpdateUDPChecksum() {
// checksum set to 0, ignored by the stack
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
ignoreCheckSum := []byte{0, 0}
p.udpHdr.udpChecksum = binary.BigEndian.Uint16(ignoreCheckSum[:])
curLen := uint16(len(buffer))
udpDataLen := curLen - p.GetUDPDataStartBytes()
// update checksum.
binary.BigEndian.PutUint16(buffer[udpChecksumPos:udpChecksumPos+2], p.udpHdr.udpChecksum)
// update length.
binary.BigEndian.PutUint16(buffer[udpLengthPos:udpLengthPos+2], udpDataLen+8)
}
|
go
|
{
"resource": ""
}
|
q6722
|
ReadUDPToken
|
train
|
func (p *Packet) ReadUDPToken() []byte {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
// 8 byte udp header, 20 byte udp marker
if len(buffer) <= udpJwtTokenOffset {
return []byte{}
}
return buffer[udpJwtTokenOffset:]
}
|
go
|
{
"resource": ""
}
|
q6723
|
UDPTokenAttach
|
train
|
func (p *Packet) UDPTokenAttach(udpdata []byte, udptoken []byte) {
udpData := []byte{}
udpData = append(udpData, udpdata...)
udpData = append(udpData, udptoken...)
packetLenIncrease := uint16(len(udpdata) + len(udptoken))
// IP Header Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, p.ipHdr.ipTotalLength+packetLenIncrease)
// Attach Data @ the end of current buffer
p.ipHdr.Buffer = append(p.ipHdr.Buffer, udpData...)
p.UpdateUDPChecksum()
}
|
go
|
{
"resource": ""
}
|
q6724
|
UDPDataAttach
|
train
|
func (p *Packet) UDPDataAttach(header, udpdata []byte) {
// Attach Data @ the end of current buffer
p.ipHdr.Buffer = append(p.ipHdr.Buffer, header...)
p.ipHdr.Buffer = append(p.ipHdr.Buffer, udpdata...)
// IP Header Processing
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, uint16(len(p.ipHdr.Buffer)))
p.UpdateUDPChecksum()
}
|
go
|
{
"resource": ""
}
|
q6725
|
CreateReverseFlowPacket
|
train
|
func (p *Packet) CreateReverseFlowPacket(destIP net.IP, destPort uint16) {
buffer := p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:]
srcAddr := binary.BigEndian.Uint32(destIP.To4())
destAddr := binary.BigEndian.Uint32(p.ipHdr.Buffer[ipv4DestAddrPos : ipv4DestAddrPos+4])
// copy the fields
binary.BigEndian.PutUint32(p.ipHdr.Buffer[ipv4SourceAddrPos:ipv4SourceAddrPos+4], destAddr)
binary.BigEndian.PutUint32(p.ipHdr.Buffer[ipv4DestAddrPos:ipv4DestAddrPos+4], srcAddr)
binary.BigEndian.PutUint16(buffer[udpSourcePortPos:udpSourcePortPos+2], p.udpHdr.destinationPort)
binary.BigEndian.PutUint16(buffer[udpDestPortPos:udpDestPortPos+2], destPort)
p.FixupIPHdrOnDataModify(p.ipHdr.ipTotalLength, uint16(p.ipHdr.ipHeaderLen+UDPDataPos))
// Just get the IP/UDP header. Ignore the rest. No need for packet
p.ipHdr.Buffer = p.ipHdr.Buffer[:p.ipHdr.ipHeaderLen+UDPDataPos]
// change the fields
p.ipHdr.sourceAddress = net.IP(p.ipHdr.Buffer[ipv4SourceAddrPos : ipv4SourceAddrPos+4])
p.ipHdr.destinationAddress = destIP
p.udpHdr.sourcePort = p.udpHdr.destinationPort
p.udpHdr.destinationPort = destPort
p.UpdateIPChecksum()
p.UpdateUDPChecksum()
}
|
go
|
{
"resource": ""
}
|
q6726
|
GetUDPType
|
train
|
func (p *Packet) GetUDPType() byte {
// Every UDP control packet has a 20 byte packet signature. The
// first 2 bytes represent the following control information.
// Byte 0 : Bits 0,1 are reserved fields.
// Bits 2,3,4 represent version information.
// Bits 5,6 represent udp packet type,
// Bit 7 represents encryption. (currently unused).
// Byte 1: reserved for future use.
// Bytes [2:20]: Packet signature.
return GetUDPTypeFromBuffer(p.ipHdr.Buffer[p.ipHdr.ipHeaderLen:])
}
|
go
|
{
"resource": ""
}
|
q6727
|
GetUDPTypeFromBuffer
|
train
|
func GetUDPTypeFromBuffer(buffer []byte) byte {
if len(buffer) < (UDPDataPos + UDPSignatureLen) {
return 0
}
marker := buffer[UDPDataPos:udpSignatureEnd]
// check for packet signature.
if !bytes.Equal(buffer[udpAuthMarkerOffset:udpSignatureEnd], []byte(UDPAuthMarker)) {
zap.L().Debug("Not an Aporeto control Packet")
return 0
}
// control packet. byte 0 has packet type information.
return marker[0] & UDPPacketMask
}
|
go
|
{
"resource": ""
}
|
q6728
|
CreateUDPAuthMarker
|
train
|
func CreateUDPAuthMarker(packetType uint8) []byte {
// Every UDP control packet has a 20 byte packet signature. The
// first 2 bytes represent the following control information.
// Byte 0 : Bits 0,1 are reserved fields.
// Bits 2,3,4 represent version information.
// Bits 5, 6, 7 represent udp packet type,
// Byte 1: reserved for future use.
// Bytes [2:20]: Packet signature.
marker := make([]byte, UDPSignatureLen)
// ignore version info as of now.
marker[0] |= packetType // byte 0
marker[1] = 0 // byte 1
// byte 2 - 19
copy(marker[2:], []byte(UDPAuthMarker))
return marker
}
|
go
|
{
"resource": ""
}
|
q6729
|
NewJWT
|
train
|
func NewJWT(validity time.Duration, issuer string, s secrets.Secrets) (*JWTConfig, error) {
if len(issuer) > MaxServerName {
return nil, fmt.Errorf("server id should be max %d chars. got %s", MaxServerName, issuer)
}
for i := len(issuer); i < MaxServerName; i++ {
issuer = issuer + " "
}
var signMethod jwt.SigningMethod
compressionType := claimsheader.CompressionTypeNone
if s == nil {
return nil, errors.New("secrets can not be nil")
}
switch s.Type() {
case secrets.PKICompactType:
signMethod = jwt.SigningMethodES256
compressionType = s.(*secrets.CompactPKI).Compressed
default:
signMethod = jwt.SigningMethodNone
}
return &JWTConfig{
ValidityPeriod: validity,
Issuer: issuer,
signMethod: signMethod,
secrets: s,
tokenCache: cache.NewCacheWithExpiration("JWTTokenCache", time.Millisecond*500),
compressionType: compressionType,
compressionTagLength: claimsheader.CompressionTypeToTagLength(compressionType),
datapathVersion: claimsheader.DatapathVersion1,
}, nil
}
|
go
|
{
"resource": ""
}
|
q6730
|
CreateAndSign
|
train
|
func (c *JWTConfig) CreateAndSign(isAck bool, claims *ConnectionClaims, nonce []byte, claimsHeader *claimsheader.ClaimsHeader) (token []byte, err error) {
// Combine the application claims with the standard claims
allclaims := &JWTClaims{
claims,
jwt.StandardClaims{
ExpiresAt: time.Now().Add(c.ValidityPeriod).Unix(),
},
}
// For backward compatibility, keep the issuer in Ack packets.
if isAck {
allclaims.Issuer = c.Issuer
}
if !isAck {
zap.L().Debug("claims", zap.Reflect("all", allclaims), zap.String("type", string(c.compressionType)))
// Handling compression here. If we need to use compression, we will copy
// the claims to the C claim and remove all the other fields.
if c.compressionType != claimsheader.CompressionTypeNone {
tags := allclaims.T
allclaims.T = nil
for _, t := range tags.Tags {
if strings.HasPrefix(t, enforcerconstants.TransmitterLabel) {
claims.ID = t[len(enforcerconstants.TransmitterLabel)+1:]
} else {
claims.C = t
}
}
zap.L().Debug("claims (post)", zap.Reflect("all", allclaims))
}
}
// Set the appropriate claims header
claimsHeader.SetCompressionType(c.compressionType)
claimsHeader.SetDatapathVersion(c.datapathVersion)
claims.H = claimsHeader.ToBytes()
// Create the token and sign with our key
strtoken, err := jwt.NewWithClaims(c.signMethod, allclaims).SignedString(c.secrets.EncodingKey())
if err != nil {
return []byte{}, err
}
// Copy the certificate if needed. Note that we don't send the certificate
// again for Ack packets to reduce overhead
if !isAck {
txKey := c.secrets.TransmittedKey()
totalLength := len(strtoken) + len(txKey) + noncePosition + NonceLength + 1
token := make([]byte, totalLength)
// Offset of public key
binary.BigEndian.PutUint16(token[0:noncePosition], uint16(len(strtoken)))
// Attach the nonse
copy(token[noncePosition:], nonce)
// Copy the JWT tokenn
copy(token[tokenPosition:], []byte(strtoken))
token[tokenPosition+len(strtoken)] = '%'
// Copy the public key
if len(txKey) > 0 {
copy(token[tokenPosition+len(strtoken)+1:], txKey)
}
return token, nil
}
return []byte(strtoken), nil
}
|
go
|
{
"resource": ""
}
|
q6731
|
Randomize
|
train
|
func (c *JWTConfig) Randomize(token []byte, nonce []byte) (err error) {
if len(token) < tokenPosition {
return errors.New("token is too small")
}
copy(token[noncePosition:], nonce)
return nil
}
|
go
|
{
"resource": ""
}
|
q6732
|
RetrieveNonce
|
train
|
func (c *JWTConfig) RetrieveNonce(token []byte) ([]byte, error) {
if len(token) < tokenPosition {
return []byte{}, errors.New("invalid token")
}
nonce := make([]byte, NonceLength)
copy(nonce, token[noncePosition:tokenPosition])
return nonce, nil
}
|
go
|
{
"resource": ""
}
|
q6733
|
addTransmitterLabel
|
train
|
func addTransmitterLabel(contextID string, containerInfo *policy.PUInfo) {
if containerInfo.Policy.ManagementID() == "" {
containerInfo.Policy.AddIdentityTag(enforcerconstants.TransmitterLabel, contextID)
} else {
containerInfo.Policy.AddIdentityTag(enforcerconstants.TransmitterLabel, containerInfo.Policy.ManagementID())
}
}
|
go
|
{
"resource": ""
}
|
q6734
|
SubOptionMonitorLinuxExtractor
|
train
|
func SubOptionMonitorLinuxExtractor(extractor extractors.EventMetadataExtractor) LinuxMonitorOption {
return func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
}
|
go
|
{
"resource": ""
}
|
q6735
|
SubOptionMonitorCNIExtractor
|
train
|
func SubOptionMonitorCNIExtractor(extractor extractors.EventMetadataExtractor) CNIMonitorOption {
return func(cfg *cnimonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
}
|
go
|
{
"resource": ""
}
|
q6736
|
SubOptionMonitorUIDExtractor
|
train
|
func SubOptionMonitorUIDExtractor(extractor extractors.EventMetadataExtractor) UIDMonitorOption {
return func(cfg *uidmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
}
|
go
|
{
"resource": ""
}
|
q6737
|
SubOptionMonitorSSHExtractor
|
train
|
func SubOptionMonitorSSHExtractor(extractor extractors.EventMetadataExtractor) LinuxMonitorOption {
return func(cfg *linuxmonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
}
|
go
|
{
"resource": ""
}
|
q6738
|
SubOptionMonitorDockerExtractor
|
train
|
func SubOptionMonitorDockerExtractor(extractor extractors.DockerMetadataExtractor) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.EventMetadataExtractor = extractor
}
}
|
go
|
{
"resource": ""
}
|
q6739
|
SubOptionMonitorDockerSocket
|
train
|
func SubOptionMonitorDockerSocket(socketType, socketAddress string) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.SocketType = socketType
cfg.SocketAddress = socketAddress
}
}
|
go
|
{
"resource": ""
}
|
q6740
|
SubOptionMonitorDockerFlags
|
train
|
func SubOptionMonitorDockerFlags(syncAtStart, killContainerOnPolicyError bool) DockerMonitorOption {
return func(cfg *dockermonitor.Config) {
cfg.KillContainerOnPolicyError = killContainerOnPolicyError
cfg.SyncAtStart = syncAtStart
}
}
|
go
|
{
"resource": ""
}
|
q6741
|
SubOptionMonitorKubernetesKubeconfig
|
train
|
func SubOptionMonitorKubernetesKubeconfig(kubeconfig string) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
}
|
go
|
{
"resource": ""
}
|
q6742
|
SubOptionMonitorKubernetesNodename
|
train
|
func SubOptionMonitorKubernetesNodename(nodename string) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.Nodename = nodename
}
}
|
go
|
{
"resource": ""
}
|
q6743
|
SubOptionMonitorKubernetesHostPod
|
train
|
func SubOptionMonitorKubernetesHostPod(enableHostPods bool) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
}
|
go
|
{
"resource": ""
}
|
q6744
|
SubOptionMonitorKubernetesExtractor
|
train
|
func SubOptionMonitorKubernetesExtractor(extractor extractors.KubernetesMetadataExtractorType) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.KubernetesExtractor = extractor
}
}
|
go
|
{
"resource": ""
}
|
q6745
|
SubOptionMonitorKubernetesDockerExtractor
|
train
|
func SubOptionMonitorKubernetesDockerExtractor(extractor extractors.DockerMetadataExtractor) KubernetesMonitorOption {
return func(cfg *kubernetesmonitor.Config) {
cfg.DockerExtractor = extractor
}
}
|
go
|
{
"resource": ""
}
|
q6746
|
SubOptionMonitorPodKubeconfig
|
train
|
func SubOptionMonitorPodKubeconfig(kubeconfig string) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.Kubeconfig = kubeconfig
}
}
|
go
|
{
"resource": ""
}
|
q6747
|
SubOptionMonitorPodNodename
|
train
|
func SubOptionMonitorPodNodename(nodename string) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.Nodename = nodename
}
}
|
go
|
{
"resource": ""
}
|
q6748
|
SubOptionMonitorPodActivateHostPods
|
train
|
func SubOptionMonitorPodActivateHostPods(enableHostPods bool) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.EnableHostPods = enableHostPods
}
}
|
go
|
{
"resource": ""
}
|
q6749
|
SubOptionMonitorPodMetadataExtractor
|
train
|
func SubOptionMonitorPodMetadataExtractor(extractor extractors.PodMetadataExtractor) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.MetadataExtractor = extractor
}
}
|
go
|
{
"resource": ""
}
|
q6750
|
SubOptionMonitorPodNetclsProgrammer
|
train
|
func SubOptionMonitorPodNetclsProgrammer(netclsprogrammer extractors.PodNetclsProgrammer) PodMonitorOption {
return func(cfg *podmonitor.Config) {
cfg.NetclsProgrammer = netclsprogrammer
}
}
|
go
|
{
"resource": ""
}
|
q6751
|
OptionCollector
|
train
|
func OptionCollector(c collector.EventCollector) Options {
return func(cfg *config.MonitorConfig) {
cfg.Common.Collector = c
}
}
|
go
|
{
"resource": ""
}
|
q6752
|
OptionPolicyResolver
|
train
|
func OptionPolicyResolver(p policy.Resolver) Options {
return func(cfg *config.MonitorConfig) {
cfg.Common.Policy = p
}
}
|
go
|
{
"resource": ""
}
|
q6753
|
NewMonitor
|
train
|
func NewMonitor(opts ...Options) *config.MonitorConfig {
cfg := &config.MonitorConfig{
Monitors: make(map[config.Type]interface{}),
}
for _, opt := range opts {
opt(cfg)
}
return cfg
}
|
go
|
{
"resource": ""
}
|
q6754
|
AddEthernetLayer
|
train
|
func (p *Packet) AddEthernetLayer(srcMACstr string, dstMACstr string) error {
if p.ethernetLayer != nil {
return errors.New("ethernet layer already exists")
}
var srcMAC, dstMAC net.HardwareAddr
//MAC address of the source
srcMAC, _ = net.ParseMAC(srcMACstr)
if srcMAC == nil {
return errors.New("no source mac given")
}
//MAC address of the destination
dstMAC, _ = net.ParseMAC(dstMACstr)
if dstMAC == nil {
return errors.New("no destination mac given")
}
//Ethernet packet header
p.ethernetLayer = &layers.Ethernet{
SrcMAC: srcMAC,
DstMAC: dstMAC,
EthernetType: layers.EthernetTypeIPv4,
}
return nil
}
|
go
|
{
"resource": ""
}
|
q6755
|
AddIPLayer
|
train
|
func (p *Packet) AddIPLayer(srcIPstr string, dstIPstr string) error {
if p.ipLayer != nil {
return errors.New("ip layer already exists")
}
var srcIP, dstIP net.IP
//IP address of the source
srcIP = net.ParseIP(srcIPstr)
if srcIP == nil {
return errors.New("no source ip given")
}
//IP address of the destination
dstIP = net.ParseIP(dstIPstr)
if dstIP == nil {
return errors.New("no destination ip given")
}
//IP packet header
p.ipLayer = &layers.IPv4{
SrcIP: srcIP,
DstIP: dstIP,
Version: 4,
TTL: 64,
Protocol: layers.IPProtocolTCP,
}
return nil
}
|
go
|
{
"resource": ""
}
|
q6756
|
AddTCPLayer
|
train
|
func (p *Packet) AddTCPLayer(srcPort layers.TCPPort, dstPort layers.TCPPort) error {
if p.tcpLayer != nil {
return errors.New("tcp layer already exists")
}
if srcPort == 0 {
return errors.New("no source tcp port given")
}
if dstPort == 0 {
return errors.New("no destination tcp port given")
}
//TCP packet header
p.tcpLayer = &layers.TCP{
SrcPort: srcPort,
DstPort: dstPort,
Window: 0,
Urgent: 0,
Seq: 0,
Ack: 0,
ACK: false,
SYN: false,
FIN: false,
RST: false,
URG: false,
ECE: false,
CWR: false,
NS: false,
PSH: false,
}
return p.tcpLayer.SetNetworkLayerForChecksum(p.ipLayer)
}
|
go
|
{
"resource": ""
}
|
q6757
|
SetTCPSynAck
|
train
|
func (p *Packet) SetTCPSynAck() {
p.tcpLayer.SYN = true
p.tcpLayer.ACK = true
p.tcpLayer.FIN = false
}
|
go
|
{
"resource": ""
}
|
q6758
|
NewTCPPayload
|
train
|
func (p *Packet) NewTCPPayload(newPayload string) error {
if p.tcpLayer.Payload != nil {
return errors.New("payload already exists")
}
p.tcpLayer.Payload = []byte(newPayload)
return nil
}
|
go
|
{
"resource": ""
}
|
q6759
|
DecodePacket
|
train
|
func (p *Packet) DecodePacket() PacketManipulator {
packetData := &Packet{
ethernetLayer: &layers.Ethernet{},
ipLayer: &layers.IPv4{},
tcpLayer: &layers.TCP{},
}
newEthernetPacket := packetData.GetEthernetPacket()
newIPPacket := packetData.GetIPPacket()
newTCPPacket := packetData.GetTCPPacket()
if ethernetLayer := p.packet.Layer(layers.LayerTypeEthernet); ethernetLayer != nil {
ethernet, _ := ethernetLayer.(*layers.Ethernet)
newEthernetPacket.SrcMAC = ethernet.SrcMAC
newEthernetPacket.DstMAC = ethernet.DstMAC
newEthernetPacket.EthernetType = ethernet.EthernetType
}
if ipLayer := p.packet.Layer(layers.LayerTypeIPv4); ipLayer != nil {
ip, _ := ipLayer.(*layers.IPv4)
newIPPacket.SrcIP = ip.SrcIP
newIPPacket.DstIP = ip.DstIP
newIPPacket.Version = ip.Version
newIPPacket.Length = ip.Length
newIPPacket.Protocol = ip.Protocol
newIPPacket.TTL = ip.TTL
}
if tcpLayer := p.packet.Layer(layers.LayerTypeTCP); tcpLayer != nil {
tcp, _ := tcpLayer.(*layers.TCP)
newTCPPacket.SrcPort = tcp.SrcPort
newTCPPacket.DstPort = tcp.DstPort
newTCPPacket.Seq = tcp.Seq
newTCPPacket.Ack = tcp.Ack
newTCPPacket.SYN = tcp.SYN
newTCPPacket.FIN = tcp.FIN
newTCPPacket.RST = tcp.RST
newTCPPacket.PSH = tcp.PSH
newTCPPacket.ACK = tcp.ACK
newTCPPacket.URG = tcp.URG
newTCPPacket.ECE = tcp.ECE
newTCPPacket.CWR = tcp.CWR
newTCPPacket.NS = tcp.NS
newTCPPacket.Checksum = tcp.Checksum
newTCPPacket.Window = tcp.Window
}
packetData = &Packet{
ethernetLayer: &newEthernetPacket,
ipLayer: &newIPPacket,
tcpLayer: &newTCPPacket,
}
return packetData
}
|
go
|
{
"resource": ""
}
|
q6760
|
NewPacketFlow
|
train
|
func NewPacketFlow(smac string, dmac string, sip string, dip string, sport layers.TCPPort, dport layers.TCPPort) PacketFlowManipulator {
initialTupules := &PacketFlow{
sMAC: smac,
dMAC: dmac,
sIP: sip,
dIP: dip,
sPort: sport,
dPort: dport,
flow: make([]PacketManipulator, 0),
}
return initialTupules
}
|
go
|
{
"resource": ""
}
|
q6761
|
AppendPacket
|
train
|
func (p *PacketFlow) AppendPacket(pm PacketManipulator) int {
p.flow = append(p.flow, pm)
return p.GetNumPackets()
}
|
go
|
{
"resource": ""
}
|
q6762
|
getMatchPackets
|
train
|
func (p *PacketFlow) getMatchPackets(syn, ack, fin bool) PacketFlowManipulator {
packetsInFlow := NewPacketFlow(p.sMAC, p.dMAC, p.sIP, p.dIP, p.sPort, p.dPort)
for j := 0; j < len(p.flow); j++ {
if p.flow[j].GetTCPSyn() == syn && p.flow[j].GetTCPAck() == ack && p.flow[j].GetTCPFin() == fin {
packetsInFlow.AppendPacket(p.flow[j])
}
}
return packetsInFlow
}
|
go
|
{
"resource": ""
}
|
q6763
|
GetUptoFirstSynAckPacket
|
train
|
func (p *PacketFlow) GetUptoFirstSynAckPacket() PacketFlowManipulator {
packetsInFlow := NewPacketFlow(p.sMAC, p.dMAC, p.sIP, p.dIP, p.sPort, p.dPort)
flag := false
for j := 0; j < len(p.flow); j++ {
if !flag {
packetsInFlow.AppendPacket(p.flow[j])
if p.flow[j].GetTCPSyn() && p.flow[j].GetTCPAck() && !p.flow[j].GetTCPFin() {
flag = true
}
}
}
return packetsInFlow
}
|
go
|
{
"resource": ""
}
|
q6764
|
GetNthPacket
|
train
|
func (p *PacketFlow) GetNthPacket(index int) PacketManipulator {
for i := 0; i < len(p.flow); i++ {
if index == i {
return p.flow[i]
}
}
panic("Index out of range")
}
|
go
|
{
"resource": ""
}
|
q6765
|
ConvertServicesToPortList
|
train
|
func ConvertServicesToPortList(services []Service) string {
portlist := ""
for _, s := range services {
portlist = portlist + s.Ports.String() + ","
}
if len(portlist) == 0 {
portlist = "0"
} else {
portlist = portlist[:len(portlist)-1]
}
return portlist
}
|
go
|
{
"resource": ""
}
|
q6766
|
NewDebugClient
|
train
|
func NewDebugClient(cr statscollector.Collector) (DebugClient, error) {
d := &debugClient{
collector: cr,
rpchdl: rpcwrapper.NewRPCWrapper(),
secret: os.Getenv(constants.EnvStatsSecret),
debugChannel: os.Getenv(constants.EnvStatsChannel),
debugInterval: defaultDebugIntervalMilliseconds * time.Millisecond,
stop: make(chan bool),
}
if d.debugChannel == "" {
return nil, errors.New("no path to debug socket provided")
}
if d.secret == "" {
return nil, errors.New("no secret provided for debug channel")
}
return d, nil
}
|
go
|
{
"resource": ""
}
|
q6767
|
CreateSocket
|
train
|
func CreateSocket(mark int, deviceName string) (SocketWriter, error) {
fd, _ := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_RAW)
if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_MARK, mark); err != nil {
syscall.Close(fd) // nolint
return nil, fmt.Errorf("Received error %s while setting socket Option SO_MARK", err)
}
if err := syscall.SetsockoptInt(fd, syscall.IPPROTO_IP, syscall.IP_HDRINCL, 1); err != nil {
syscall.Close(fd) // nolint
return nil, fmt.Errorf("Received error %s while setting socket Option IP_HDRINCL", err)
}
insock := &syscall.SockaddrInet4{
Port: 0,
}
return &rawsocket{
fd: fd,
insock: insock,
}, nil
}
|
go
|
{
"resource": ""
}
|
q6768
|
NewPUInfo
|
train
|
func NewPUInfo(contextID string, puType common.PUType) *PUInfo {
policy := NewPUPolicy(contextID, AllowAll, nil, nil, nil, nil, nil, nil, nil, nil, 0, nil, nil, []string{})
runtime := NewPURuntime("", 0, "", nil, nil, puType, nil)
return PUInfoFromPolicyAndRuntime(contextID, policy, runtime)
}
|
go
|
{
"resource": ""
}
|
q6769
|
PUInfoFromPolicyAndRuntime
|
train
|
func PUInfoFromPolicyAndRuntime(contextID string, policyInfo *PUPolicy, runtimeInfo *PURuntime) *PUInfo {
return &PUInfo{
ContextID: contextID,
Policy: policyInfo,
Runtime: runtimeInfo,
}
}
|
go
|
{
"resource": ""
}
|
q6770
|
ErrPUNotFound
|
train
|
func ErrPUNotFound(puID string, err error) error {
return &Error{
puID: puID,
reason: PUNotFound,
err: err,
}
}
|
go
|
{
"resource": ""
}
|
q6771
|
ErrPUNotUnique
|
train
|
func ErrPUNotUnique(puID string, err error) error {
return &Error{
puID: puID,
reason: PUNotUnique,
err: err,
}
}
|
go
|
{
"resource": ""
}
|
q6772
|
ErrPUCreateFailed
|
train
|
func ErrPUCreateFailed(puID string, err error) error {
return &Error{
puID: puID,
reason: PUCreateFailed,
err: err,
}
}
|
go
|
{
"resource": ""
}
|
q6773
|
ErrPUAlreadyActivated
|
train
|
func ErrPUAlreadyActivated(puID string, err error) error {
return &Error{
puID: puID,
reason: PUAlreadyActivated,
err: err,
}
}
|
go
|
{
"resource": ""
}
|
q6774
|
ErrPUPolicyPending
|
train
|
func ErrPUPolicyPending(puID string, err error) error {
return &Error{
puID: puID,
reason: PUPolicyPending,
err: err,
}
}
|
go
|
{
"resource": ""
}
|
q6775
|
ErrPUPolicyEnforcementFailed
|
train
|
func ErrPUPolicyEnforcementFailed(puID string, err error) error {
return &Error{
puID: puID,
reason: PUPolicyEnforcementFailed,
err: err,
}
}
|
go
|
{
"resource": ""
}
|
q6776
|
IsErrPUNotFound
|
train
|
func IsErrPUNotFound(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUNotFound
default:
return false
}
}
|
go
|
{
"resource": ""
}
|
q6777
|
IsErrPUNotUnique
|
train
|
func IsErrPUNotUnique(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUNotUnique
default:
return false
}
}
|
go
|
{
"resource": ""
}
|
q6778
|
IsErrPUCreateFailed
|
train
|
func IsErrPUCreateFailed(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUCreateFailed
default:
return false
}
}
|
go
|
{
"resource": ""
}
|
q6779
|
IsErrPUAlreadyActivated
|
train
|
func IsErrPUAlreadyActivated(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUAlreadyActivated
default:
return false
}
}
|
go
|
{
"resource": ""
}
|
q6780
|
IsErrPUPolicyPending
|
train
|
func IsErrPUPolicyPending(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUPolicyPending
default:
return false
}
}
|
go
|
{
"resource": ""
}
|
q6781
|
IsErrPUEnforcementFailed
|
train
|
func IsErrPUEnforcementFailed(err error) bool {
switch t := err.(type) {
case *Error:
return t.reason == PUPolicyEnforcementFailed
default:
return false
}
}
|
go
|
{
"resource": ""
}
|
q6782
|
ExecuteCommandFromArguments
|
train
|
func ExecuteCommandFromArguments(arguments map[string]interface{}) error {
p := NewRequestProcessor()
c, err := p.ParseCommand(arguments)
if err != nil {
return err
}
return p.ExecuteRequest(c)
}
|
go
|
{
"resource": ""
}
|
q6783
|
NewCustomRequestProcessor
|
train
|
func NewCustomRequestProcessor(address string) *RequestProcessor {
r := NewRequestProcessor()
if address != "" {
r.address = address
}
return r
}
|
go
|
{
"resource": ""
}
|
q6784
|
CreateAndRun
|
train
|
func (r *RequestProcessor) CreateAndRun(c *CLIRequest) error {
var err error
// If its not hostPolicy and the command doesn't exist we return an error
if !c.HostPolicy {
if c.Executable == "" {
return errors.New("command must be provided")
}
if !path.IsAbs(c.Executable) {
c.Executable, err = exec.LookPath(c.Executable)
if err != nil {
return err
}
}
if c.ServiceName == "" {
c.ServiceName = c.Executable
}
}
puType := common.LinuxProcessPU
if c.NetworkOnly {
puType = common.HostNetworkPU
} else if c.HostPolicy {
puType = common.HostPU
}
// This is added since the release_notification comes in this format
// Easier to massage it while creation rather than change at the receiving end depending on event
request := &common.EventInfo{
PUType: puType,
Name: c.ServiceName,
Executable: c.Executable,
Tags: c.Labels,
PID: int32(os.Getpid()),
EventType: common.EventStart,
Services: c.Services,
NetworkOnlyTraffic: c.NetworkOnly,
HostService: c.HostPolicy,
AutoPort: c.AutoPort,
}
if err := sendRequest(r.address, request); err != nil {
return err
}
if c.HostPolicy {
return nil
}
env := os.Environ()
env = append(env, "APORETO_WRAP=1")
return syscall.Exec(c.Executable, append([]string{c.Executable}, c.Parameters...), env)
}
|
go
|
{
"resource": ""
}
|
q6785
|
DeleteService
|
train
|
func (r *RequestProcessor) DeleteService(c *CLIRequest) error {
request := &common.EventInfo{
PUType: common.LinuxProcessPU,
PUID: c.ServiceName,
EventType: common.EventStop,
HostService: c.HostPolicy,
}
if c.UIDPolicy {
request.PUType = common.UIDLoginPU
}
// Send Stop request
if err := sendRequest(r.address, request); err != nil {
return err
}
// Send destroy request
request.EventType = common.EventDestroy
return sendRequest(r.address, request)
}
|
go
|
{
"resource": ""
}
|
q6786
|
DeleteCgroup
|
train
|
func (r *RequestProcessor) DeleteCgroup(c *CLIRequest) error {
regexCgroup := regexp.MustCompile(`^/trireme/(ssh-)?[a-zA-Z0-9_\-:.$%]{1,64}$`)
regexUser := regexp.MustCompile(`^/trireme_uid/[a-zA-Z0-9_\-]{1,32}(/[0-9]{1,32}){0,1}$`)
if !regexCgroup.Match([]byte(c.Cgroup)) && !regexUser.Match([]byte(c.Cgroup)) {
return fmt.Errorf("invalid cgroup: %s", c.Cgroup)
}
var eventPUID string
var eventType common.PUType
if strings.HasPrefix(c.Cgroup, common.TriremeUIDCgroupPath) {
eventType = common.UIDLoginPU
eventPUID = c.Cgroup[len(common.TriremeUIDCgroupPath):]
} else if strings.HasPrefix(c.Cgroup, common.TriremeCgroupPath+"ssh-") {
eventType = common.SSHSessionPU
eventPUID = c.Cgroup[len(common.TriremeCgroupPath)+4:]
} else if strings.HasPrefix(c.Cgroup, common.TriremeCgroupPath) {
eventType = common.LinuxProcessPU
eventPUID = c.Cgroup[len(common.TriremeCgroupPath):]
} else {
// Not our Cgroup
return nil
}
request := &common.EventInfo{
PUType: eventType,
PUID: eventPUID,
EventType: common.EventStop,
}
// Send Stop request
if err := sendRequest(r.address, request); err != nil {
return err
}
// Send destroy request
request.EventType = common.EventDestroy
return sendRequest(r.address, request)
}
|
go
|
{
"resource": ""
}
|
q6787
|
ExecuteRequest
|
train
|
func (r *RequestProcessor) ExecuteRequest(c *CLIRequest) error {
switch c.Request {
case CreateRequest:
return r.CreateAndRun(c)
case DeleteCgroupRequest:
return r.DeleteCgroup(c)
case DeleteServiceRequest:
return r.DeleteService(c)
default:
return fmt.Errorf("unknown request: %d", c.Request)
}
}
|
go
|
{
"resource": ""
}
|
q6788
|
sendRequest
|
train
|
func sendRequest(address string, event *common.EventInfo) error {
client, err := client.NewClient(address)
if err != nil {
return err
}
return client.SendRequest(event)
}
|
go
|
{
"resource": ""
}
|
q6789
|
ParseServices
|
train
|
func ParseServices(ports []string) ([]common.Service, error) {
// If no ports are provided, we add the default 0 port
if len(ports) == 0 {
ports = append(ports, "0")
}
// Parse the ports and create the services. Cleanup any bad ports
services := []common.Service{}
protocol := packet.IPProtocolTCP
for _, p := range ports {
// check for port string of form port#/udp eg 8085/udp
portProtocolPair := strings.Split(p, "/")
if len(portProtocolPair) > 2 || len(portProtocolPair) <= 0 {
return nil, fmt.Errorf("Invalid port format. Expected format is of form 80 or 8085/udp")
}
if len(portProtocolPair) == 2 {
if portProtocolPair[1] == "tcp" {
protocol = packet.IPProtocolTCP
} else if portProtocolPair[1] == "udp" {
protocol = packet.IPProtocolUDP
} else {
return nil, fmt.Errorf("Invalid protocol specified. Only tcp/udp accepted")
}
}
s, err := portspec.NewPortSpecFromString(portProtocolPair[0], nil)
if err != nil {
return nil, fmt.Errorf("Invalid port spec: %s ", err)
}
services = append(services, common.Service{
Protocol: uint8(protocol),
Ports: s,
})
}
return services, nil
}
|
go
|
{
"resource": ""
}
|
q6790
|
ComputeHmac256
|
train
|
func ComputeHmac256(tags []byte, key []byte) ([]byte, error) {
var buffer bytes.Buffer
if err := binary.Write(&buffer, binary.BigEndian, tags); err != nil {
return []byte{}, err
}
h := hmac.New(sha256.New, key)
if _, err := h.Write(buffer.Bytes()); err != nil {
return []byte{}, err
}
return h.Sum(nil), nil
}
|
go
|
{
"resource": ""
}
|
q6791
|
VerifyHmac
|
train
|
func VerifyHmac(tags []byte, expectedMAC []byte, key []byte) bool {
messageMAC, err := ComputeHmac256(tags, key)
if err != nil {
return false
}
return hmac.Equal(messageMAC, expectedMAC)
}
|
go
|
{
"resource": ""
}
|
q6792
|
GenerateRandomBytes
|
train
|
func GenerateRandomBytes(n int) ([]byte, error) {
b := make([]byte, n)
_, err := rand.Read(b)
if err != nil {
zap.L().Debug("GenerateRandomBytes failed", zap.Error(err))
return nil, err
}
s := base64.StdEncoding.EncodeToString(b)
return []byte(s[:n]), nil
}
|
go
|
{
"resource": ""
}
|
q6793
|
GenerateRandomString
|
train
|
func GenerateRandomString(s int) (string, error) {
b, err := GenerateRandomBytes(s)
return base64.URLEncoding.EncodeToString(b), err
}
|
go
|
{
"resource": ""
}
|
q6794
|
LoadRootCertificates
|
train
|
func LoadRootCertificates(rootPEM []byte) *x509.CertPool {
roots := x509.NewCertPool()
ok := roots.AppendCertsFromPEM(rootPEM)
if !ok {
zap.L().Error("AppendCertsFromPEM failed", zap.ByteString("rootPEM", rootPEM))
return nil
}
return roots
}
|
go
|
{
"resource": ""
}
|
q6795
|
LoadEllipticCurveKey
|
train
|
func LoadEllipticCurveKey(keyPEM []byte) (*ecdsa.PrivateKey, error) {
block, _ := pem.Decode(keyPEM)
if block == nil {
return nil, fmt.Errorf("LoadElliticCurveKey bad pem block: %s", string(keyPEM))
}
// Parse the key
key, err := x509.ParseECPrivateKey(block.Bytes)
if err != nil {
return nil, err
}
return key, nil
}
|
go
|
{
"resource": ""
}
|
q6796
|
LoadAndVerifyCertificate
|
train
|
func LoadAndVerifyCertificate(certPEM []byte, roots *x509.CertPool) (*x509.Certificate, error) {
cert, err := LoadCertificate(certPEM)
if err != nil {
return nil, err
}
opts := x509.VerifyOptions{
Roots: roots,
}
if _, err := cert.Verify(opts); err != nil {
return nil, err
}
return cert, nil
}
|
go
|
{
"resource": ""
}
|
q6797
|
LoadAndVerifyECSecrets
|
train
|
func LoadAndVerifyECSecrets(keyPEM, certPEM, caCertPEM []byte) (key *ecdsa.PrivateKey, cert *x509.Certificate, rootCertPool *x509.CertPool, err error) {
// Parse the key
key, err = LoadEllipticCurveKey(keyPEM)
if err != nil {
return nil, nil, nil, err
}
rootCertPool = LoadRootCertificates(caCertPEM)
if rootCertPool == nil {
return nil, nil, nil, errors.New("unable to load root certificate pool")
}
cert, err = LoadAndVerifyCertificate(certPEM, rootCertPool)
if err != nil {
return nil, nil, nil, err
}
return key, cert, rootCertPool, nil
}
|
go
|
{
"resource": ""
}
|
q6798
|
LoadCertificate
|
train
|
func LoadCertificate(certPEM []byte) (*x509.Certificate, error) {
// Decode the certificate
certBlock, _ := pem.Decode(certPEM)
if certBlock == nil {
return nil, fmt.Errorf("unable to parse pem block: %s", string(certPEM))
}
// Create the certificate structure
cert, err := x509.ParseCertificate(certBlock.Bytes)
if err != nil {
return nil, err
}
return cert, nil
}
|
go
|
{
"resource": ""
}
|
q6799
|
NewRPCClient
|
train
|
func (m *MockRPCClient) NewRPCClient(contextID, channel, rpcSecret string) error {
ret := m.ctrl.Call(m, "NewRPCClient", contextID, channel, rpcSecret)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.