From fef9153a127cc70fdb40d56135d06626900a078c Mon Sep 17 00:00:00 2001 From: Christopher Tarry Date: Sat, 20 Nov 2021 13:53:30 -0500 Subject: [PATCH] initial commit --- LICENSE | 7 + README.md | 105 + go.mod | 11 + go.sum | 19 + hulu/client.go | 232 ++ hulu/types.go | 981 +++++++ main.go | 170 ++ proto/wv_proto2.proto | 468 ++++ widevine/cdm.go | 269 ++ widevine/consts.go | 38 + widevine/pssh.go | 115 + widevine/wv_proto2.pb.go | 5729 ++++++++++++++++++++++++++++++++++++++ 12 files changed, 8144 insertions(+) create mode 100644 LICENSE create mode 100644 README.md create mode 100644 go.mod create mode 100644 go.sum create mode 100644 hulu/client.go create mode 100644 hulu/types.go create mode 100644 main.go create mode 100644 proto/wv_proto2.proto create mode 100644 widevine/cdm.go create mode 100644 widevine/consts.go create mode 100644 widevine/pssh.go create mode 100644 widevine/wv_proto2.pb.go diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..43f86a9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,7 @@ +Copyright © 2021 Christopher Tarry + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..092666e --- /dev/null +++ b/README.md @@ -0,0 +1,105 @@ +# Hulu Downloader + +The code in this repository allows you to download videos unencumbered with DRM from Hulu. The code in `widevine` is in general independent of the Hulu related code and can be used for Widevine license generation/decryption. The code in `hulu` is also standalone but only implements a handful of endpoints that are basically only useful for a command line tool of this nature. + +## Prerequisites +The code in this repository by itself does not require any external libraries or tools to be installed. It merely finds the video URLs and decryption keys. The only dependencies required are cryptographic libraraies specified in go.mod but Go should handle these automatically. However, to actually perform MP4 decryption, Bento4 (and specifically its `mp4decrypt` tool) are required. Bento4 is an open source library for MP4 manipulation. Binary releases of its tools can be downloaded [here](https://www.bento4.com/downloads/). [`yt-dlp`](https://github.com/yt-dlp/yt-dlp) is also required to download the MPD playlist files to mp4s. Technically, this could be implemented rather easily in this repository but I want to keep this repository simple and avoid rewriting code to deal with segment merging or quality selection menus. + +## Retrieving Hulu Session Cookie +Hulu requires Recaptcha for authentication so just passing account credentials is not possible without captcha solving services. To work around this, this tool simply takes a Hulu session cookie. + +> Note: Ensure you are signed in before following these steps. + +### Chrome +Visit [https://hulu.com](https://hulu.com). Click the lock icon in the URL bar. Then select the item labelled Cookies. Then find hulu.com in the list, select it, and expand the "Cookies" list with an icon that looks like a folder. Then select the cookie titled `_hulu_session`. Chrome will then show various attributes of this cookie. Right click the area labelled "Content", press select all and then right click again and press copy. The value of the Hulu session cookie is now on your clipboard. A demonstration can be found [here](https://www.cookieyes.com/wp-content/uploads/2021/10/chrome2.mp4). + +### Firefox +Visit [https://hulu.com](https://hulu.com). Right click and then click Inspect. Then visit the Storage tab. Now, under the cookies pane on the left, select hulu.com. Then retrieve the value of `_hulu_session` from the list of cookies. A demonstration can be found [here](https://www.cookieyes.com/wp-content/uploads/2021/10/firefox1.mp4). + +## Demonstration + +Say we want to download an episode of M\*A\*S\*H. + + $ go install github.com/chris124567/hulu # The rest of these commands assume $GOPATH/bin is in your PATH. If it is not, just cd to $GOPATH/bin and run "./hulu" instead of "hulu" + $ HULU_SESSION="abc" hulu search -query="m*a*s*h" + Title ID + M*A*S*H ae94231d-0f04-482a-b9ee-9911e339e3ed + MASH (1970) 42f7eefe-2448-4ed5-87cb-6233c89c20f6 + American Psycho (2000) 404a410c-ef36-469d-8fcd-1f93ec44a5c0 + American Horror Story a67a233c-fcfe-4e8e-b000-052603ddd616 + Hitman: Agent 47 (2015) a4d96c8d-ba7d-4d99-b4b3-942ecde47282 + Ma (2019) dbb13a18-79d2-4567-8ed4-e2eddbec9492 + The Martian (2015) e52328e3-6e2b-4565-91d5-2f7ee7c846ab + HBO Max 1b3523c1-3090-4c27-a1e8-a04d33867c34 + ... + +We want the M\*A\*S\*H TV show, so we choose the ID "ae94231d-0f04-482a-b9ee-9911e339e3ed." We want to look at the first season so we specify that the season number equals 1. + + $ HULU_SESSION="abc" hulu season -id="ae94231d-0f04-482a-b9ee-9911e339e3ed" -number=1 + Title ID + Pilot 4045ee04-07e8-4c33-94a6-4244b7b67c5f + To Market, to Market 7a43d075-2b47-4c94-8767-8531e20bab81 + Requiem for a Lightweight 2ccd2cf5-a013-4501-a689-1ed6b94a9549 + Chief Surgeon Who? 112b061b-1c18-4f15-bed8-042d44919735 + The Moose 688e10d3-6db4-47ba-a99b-bfd8aacd6c7a + Yankee Doodle Doctor 3ff14d70-e2ac-4bc2-83c6-87b9cf132c13 + ... + +Now to get the episode we want (the pilot), pass the ID of the episode to the `download` subcommand. + +> Note: If we wanted to download a movie, instead of getting the episode list (which movies don't have) and selecting the specific episode ID, just pass the original ID from the search results above to `download`. + + + $ HULU_SESSION="abc" hulu download -id="4045ee04-07e8-4c33-94a6-4244b7b67c5f" + MPD URL: https://manifest-dp.hulustream.com/OMITTED + Decryption command: mp4decrypt input.mp4 output.mp4 --key OMITTED:OMITTED + +Now we have the URL and the keys. First, let's see what formats are available: + + $ yt-dlp --allow-unplayable-formats -F "https://manifest-dp.hulustream.com/OMITTED" + WARNING: You have asked for unplayable formats to be listed/downloaded. This is a developer option intended for debugging. + If you experience any issues while using this option, DO NOT open a bug report + [generic] xxxxxxxx: Requesting header + WARNING: [generic] Falling back on generic information extractor. + [generic] xxxxxxxx: Downloading webpage + [generic] xxxxxxxx: Extracting information + [info] Available formats for xxxxxxxx: + ID EXT RESOLUTION | TBR PROTO | VCODEC VBR ACODEC ABR ASR MORE INFO + ---------------- --- ---------- - ----- ----- - ----------- ----- --------- ---- ------- -------------------------- + 132545434.add-0 m4a audio only | 68k https | mp4a.40.5 68k 48000Hz [en], DASH audio, m4a_dash + 132545434.add-1 m4a audio only | 68k https | mp4a.40.5 68k 48000Hz [en], DASH audio, m4a_dash + ... + 132545434.add-11 m4a audio only | 68k https | mp4a.40.5 68k 48000Hz [en], DASH audio, m4a_dash + 132545134.vdd-0 mp4 512x288 | 460k https | avc1.640015 460k DASH video, mp4_dash + 132545134.vdd-1 mp4 512x288 | 460k https | avc1.640015 460k DASH video, mp4_dash + ... + 132545134.vdd-11 mp4 512x288 | 460k https | avc1.640015 460k DASH video, mp4_dash + +Let's get the audio first. We will choose `132545434.add-0`, the lowest quality format, for this example. Download it with: + + $ yt-dlp --allow-unplayable-formats -f "132545434.add-0" "https://manifest-dp.hulustream.com/OMITTED" -o audio.mp4 + +Next we will get the video. We will also just take the lowest quality format (`132545134.vdd-0`) here. + + $ yt-dlp --allow-unplayable-formats -f "132545134.vdd-0" "https://manifest-dp.hulustream.com/OMITTED" -o video.mp4 + +Now we should have two mp4 files, one for the video and one for the audio. We ultimately will merge these, but first we need to decrypt them. + +Remember the mp4decrypt command from above? Specifically look at the `--key OMITTED:OMITTED` part. The decryption key is the same for both the video and the audio. So we can run: + + $ mp4decrypt audio.mp4 audio_dec.mp4 --key OMITTED:OMITTED + $ mp4decrypt video.mp4 video_dec.mp4 --key OMITTED:OMITTED + +Finally, we can merge the two sources (this command does not do any reencoding): + + $ ffmpeg -i video_dec.mp4 -i audio_dec.mp4 -acodec copy -vcodec copy merged.mp4 + +And now merged.mp4 will be a DRM free mp4 file straight from Hulu! It is possible to automate nearly all of these steps by writing a simple script. + +## TODO +- Subtitles +- Storing authentication cookie in a text file to avoid having to pass it for every command + +## Credits + +The bulk of the Widevine related code was ported from `pywidevine` which is a library floating around the Internet of unknown provenance. \ No newline at end of file diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..83c537a --- /dev/null +++ b/go.mod @@ -0,0 +1,11 @@ +module github.com/chris124567/hulu + +go 1.16 + +require ( + github.com/aead/cmac v0.0.0-20160719120800-7af84192f0b1 + golang.org/x/sys v0.0.0-20210423082822-04245dca01da // indirect + google.golang.org/protobuf v1.27.1 + lukechampine.com/flagg v1.1.1 + lukechampine.com/frand v1.4.2 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..f866122 --- /dev/null +++ b/go.sum @@ -0,0 +1,19 @@ +github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da h1:KjTM2ks9d14ZYCvmHS9iAKVt9AyzRSqNU1qabPih5BY= +github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da/go.mod h1:eHEWzANqSiWQsof+nXEI9bUVUyV6F53Fp89EuCh2EAA= +github.com/aead/cmac v0.0.0-20160719120800-7af84192f0b1 h1:+JkXLHME8vLJafGhOH4aoV2Iu8bR55nU6iKMVfYVLjY= +github.com/aead/cmac v0.0.0-20160719120800-7af84192f0b1/go.mod h1:nuudZmJhzWtx2212z+pkuy7B6nkBqa+xwNXZHL1j8cg= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +lukechampine.com/flagg v1.1.1 h1:jB5oL4D5zSUrzm5og6dDEi5pnrTF1poKfC7KE1lLsqc= +lukechampine.com/flagg v1.1.1/go.mod h1:a9ZuZu5LSPXELWSJrabRD00ort+lDXSOQu34xWgEoDI= +lukechampine.com/frand v1.4.2 h1:RzFIpOvkMXuPMBb9maa4ND4wjBn71E1Jpf8BzJHMaVw= +lukechampine.com/frand v1.4.2/go.mod h1:4S/TM2ZgrKejMcKMbeLjISpJMO+/eZ1zu3vYX9dtj3s= diff --git a/hulu/client.go b/hulu/client.go new file mode 100644 index 0000000..1651e91 --- /dev/null +++ b/hulu/client.go @@ -0,0 +1,232 @@ +package hulu + +import ( + "bytes" + "crypto/aes" + "crypto/cipher" + "crypto/md5" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "lukechampine.com/frand" + "net/http" + "net/url" + "strconv" + "strings" + "time" +) + +const ( + contentTypeJSON = "application/json" + contentTypeForm = "application/x-www-form-urlencoded" +) + +type Client struct { + c *http.Client + huluSession string + huluGUID string +} + +// Returns a Client object that will use the provided Hulu session cookie to +// interact with the Hulu API. +func NewClient(c *http.Client, huluSession string) Client { + // they look something like 5E95F69687FDD039CD0388A39FC01E5A + huluGUID := func() (s string) { + c := []byte("ABCDEF0123456789") + for i := 0; i < 32; i++ { + s += string(c[frand.Intn(len(c))]) + } + return + }() + + return Client{c, huluSession, huluGUID} +} + +// Returns a Client object using a default HTTP client with a timeout of 10s. +func NewDefaultClient(huluSession string) Client { + return NewClient(&http.Client{ + Timeout: 10 * time.Second, + }, huluSession) +} + +// Makes an HTTP request to a Hulu API endpoint. The only cookie Hulu validates is +// the session cookie so we just provide it alone. +func (c Client) request(method string, url string, data io.Reader, contentType string) (*http.Response, error) { + request, err := http.NewRequest(method, url, data) + if err != nil { + return nil, err + } + request.Close = true + request.Header = StandardHeaders() + request.Header.Set("Cookie", "_hulu_session="+c.huluSession) + if method == http.MethodPost && len(contentType) > 0 { + request.Header.Set("Content-Type", contentType) + } + return c.c.Do(request) +} + +// Queries the Hulu entity search API endpoint for shows and movies. This can +// return content that you do not have the right subscription for (like stuff +// requiring an HBO subscription) so be mindful of that. +func (c Client) Search(query string) (s SearchResults, err error) { + query = url.QueryEscape(query) + response, err := c.request(http.MethodGet, fmt.Sprintf("https://discover.hulu.com/content/v5/search/entity?language=en&device_context_id=2&search_query=%s&limit=64&include_offsite=true&v=26e1061d-68ec-48bf-be5a-b2f704d37256&schema=1&device_info=web:3.29.0&referralHost=production&keywords=%s&type=entity&limit=64", query, query), nil, "") + if err != nil { + return + } + defer response.Body.Close() + err = json.NewDecoder(response.Body).Decode(&s) + return +} + +// Returns the season information containing the episode list in a given season +// for a given show. +func (c Client) Season(id string, season int) (s Season, err error) { + response, err := c.request(http.MethodGet, fmt.Sprintf("https://discover.hulu.com/content/v5/hubs/series/%s/season/%d?limit=999&schema=1&offset=0&device_info=web:3.29.0&referralHost=production", id, season), nil, "") + if err != nil { + return + } + defer response.Body.Close() + err = json.NewDecoder(response.Body).Decode(&s) + return +} + +// The /config endpoint returns a large hex encoded string. This string then +// has to be decoded using a hardcoded key from Hulu. The decoded data is JSON +// containing a bunch of configuration options for the player. More importantly, +// it contains the KeyID field which is needed to call Playlist. +func (c Client) ServerConfig() (co Config, err error) { + rv := strconv.Itoa(int(frand.Uint64n(1e6))) + base := strings.Join([]string{hex.EncodeToString(deejayKey), strconv.Itoa(deejayDeviceID), strconv.Itoa(deejayKeyVersion), rv}, ",") + nonce := md5.Sum([]byte(base)) + + values := url.Values{} + values.Add("app_version", strconv.Itoa(deejayKeyVersion)) + values.Add("badging", "true") + values.Add("device", strconv.Itoa(deejayDeviceID)) + values.Add("device_id", c.huluGUID) + values.Add("encrypted_nonce", hex.EncodeToString(nonce[:])) + values.Add("language", "en") + values.Add("region", "US") + values.Add("rv", rv) + values.Add("version", strconv.Itoa(deejayKeyVersion)) + + response, err := c.request(http.MethodPost, "https://play.hulu.com/config", strings.NewReader(values.Encode()), contentTypeForm) + if err != nil { + return + } + defer response.Body.Close() + + ciphertext, err := io.ReadAll(hex.NewDecoder(response.Body)) + if err != nil { + return + } + + block, err := aes.NewCipher(deejayKey) + if err != nil { + return + } + + dec := cipher.NewCBCDecrypter(block, make([]byte, 16)) + unpad := func(b []byte) []byte { + if len(b) == 0 { + return b + } + // pks padding is designed so that the value of all the padding bytes is + // the number of padding bytes repeated so to figure out how many + // padding bytes there are we can just look at the value of the last + // byte + // i.e if there are 6 padding bytes then it will look at like + // 0x6 0x6 0x6 0x6 0x6 0x6 + count := int(b[len(b)-1]) + return b[0 : len(b)-count] + } + plaintext := make([]byte, len(ciphertext)) + dec.CryptBlocks(plaintext, ciphertext) + err = json.Unmarshal(unpad(plaintext), &co) + return +} + +// This allows us to get the EAB ID for a given plain ID. The EAB ID is +// necessary to call Playlist. +func (c Client) PlaybackInformation(id string) (p PlaybackInformation, err error) { + response, err := c.request(http.MethodGet, fmt.Sprintf("https://discover.hulu.com/content/v5/deeplink/playback?namespace=entity&id=%s&schema=1&device_info=web:3.29.0&referralHost=production", id), nil, "") + if err != nil { + return + } + defer response.Body.Close() + err = json.NewDecoder(response.Body).Decode(&p) + return +} + +// Playlist returns information containing the Widevine license endpoint, +// the MPD file URL, and information relating to subtitles (Hulu calls them +// transcripts). +func (c Client) Playlist(sessionKey int, eabID string) (p Playlist, err error) { + randUUID := func() (s string) { + randChars := func(n int) (s string) { + c := []byte("ABCDEF0123456789") + for i := 0; i < 4; i++ { + s += string(c[frand.Intn(len(c))]) + } + return + } + return strings.Join([]string{randChars(8), randChars(4), randChars(4), randChars(4), randChars(12)}, "-") + } + + playlistRequest := PlaylistRequest{ + DeviceIdentifier: c.huluGUID + ":d40b", + DeejayDeviceID: deejayDeviceID, + Version: deejayKeyVersion, + AllCdn: true, + ContentEabID: eabID, + Region: "US", + XlinkSupport: false, + DeviceAdID: randUUID(), + LimitAdTracking: false, + IgnoreKidsBlock: false, + Language: "en", + GUID: c.huluGUID, + Rv: int(frand.Uint64n(1e7)), + Kv: sessionKey, + Unencrypted: true, + IncludeT2RevenueBeacon: "1", + CpSessionID: randUUID(), + NetworkMode: "wifi", + PlayIntent: "resume", + Playback: PlaylistRequestPlayback{ + Version: 2, + Video: PlaylistRequestVideo{Codecs: PlaylistRequestCodecs{Values: []PlaylistRequestValues{{Type: "H264", Profile: "HIGH", Level: "4.1", Framerate: 30}}, SelectionMode: "ONE"}}, + Audio: PlaylistRequestAudio{Codecs: PlaylistRequestCodecs{Values: []PlaylistRequestValues{{Type: "AAC"}}, SelectionMode: "ONE"}}, + DRM: PlaylistRequestDRM{Values: []PlaylistRequestValues{{Type: "WIDEVINE", Version: "MODULAR", SecurityLevel: "L3"}}, SelectionMode: "ONE"}, + Manifest: PlaylistRequestManifest{ + Type: "DASH", + HTTPS: true, + MultipleCdns: true, + PatchUpdates: true, + HuluTypes: true, + LiveDai: true, + MultiplePeriods: true, + Xlink: false, + SecondaryAudio: true, + LiveFragmentDelay: 3, + }, + Segments: PlaylistRequestSegments{Values: []PlaylistRequestValues{{Type: "FMP4", Encryption: &PlaylistRequestEncryption{Mode: "CENC", Type: "CENC"}, HTTPS: true}}, SelectionMode: "ONE"}, + }, + } + + var buf bytes.Buffer + if err = json.NewEncoder(&buf).Encode(playlistRequest); err != nil { + return + } + + response, err := c.request(http.MethodPost, "https://play.hulu.com/v6/playlist", &buf, contentTypeJSON) + if err != nil { + return + } + defer response.Body.Close() + + err = json.NewDecoder(response.Body).Decode(&p) + return +} diff --git a/hulu/types.go b/hulu/types.go new file mode 100644 index 0000000..b9f23c0 --- /dev/null +++ b/hulu/types.go @@ -0,0 +1,981 @@ +package hulu + +import ( + "net/http" + "time" +) + +var ( + deejayKey = []byte{110, 191, 200, 79, 60, 48, 66, 23, 178, 15, 217, 166, 108, 181, 149, 127} +) + +const ( + deejayDeviceID = 190 + deejayKeyVersion = 1 +) + +func StandardHeaders() http.Header { + return http.Header{ + http.CanonicalHeaderKey("sec-ch-ua"): []string{`" Not A;Brand";v="99"}, "Chromium";v="96"}, "Google Chrome";v="96"`}, + http.CanonicalHeaderKey("sec-ch-ua-mobile"): []string{"?0"}, + http.CanonicalHeaderKey("User-Agent"): []string{"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36"}, + http.CanonicalHeaderKey("sec-ch-ua-platform"): []string{`"Linux"`}, + http.CanonicalHeaderKey("Accept"): []string{"*/*"}, + http.CanonicalHeaderKey("Origin"): []string{"https://www.hulu.com"}, + http.CanonicalHeaderKey("Sec-Fetch-Site"): []string{"same-site"}, + http.CanonicalHeaderKey("Sec-Fetch-Mode"): []string{"cors"}, + http.CanonicalHeaderKey("Sec-Fetch-Dest"): []string{"empty"}, + http.CanonicalHeaderKey("Referer"): []string{"https://www.hulu.com/"}, + http.CanonicalHeaderKey("Accept-Language"): []string{"en-US,en;q=0.9"}, + } +} + +type SearchResults struct { + Groups []struct { + Category string `json:"category"` + Results []struct { + Type string `json:"_type"` + MetricsInfo struct { + TargetID string `json:"target_id"` + TargetType string `json:"target_type"` + TargetName string `json:"target_name"` + SelectionTrackingID string `json:"selection_tracking_id"` + } `json:"metrics_info"` + Personalization struct { + BowieContext string `json:"bowie_context"` + Eab string `json:"eab"` + } `json:"personalization"` + DeviceContextFailure bool `json:"device_context_failure"` + ViewTemplate string `json:"view_template"` + Visuals struct { + Artwork struct { + Type string `json:"_type"` + Horizontal struct { + Type string `json:"_type"` + ArtworkType string `json:"artwork_type"` + Image struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageID string `json:"image_id"` + } `json:"image"` + Text string `json:"text"` + } `json:"horizontal"` + } `json:"artwork"` + Headline struct { + Text string `json:"text"` + Index [][]int `json:"index"` + } `json:"headline"` + Body struct { + Text string `json:"text"` + Index [][]int `json:"index"` + } `json:"body"` + ActionText string `json:"action_text"` + PrimaryBranding struct { + ID string `json:"id"` + Name string `json:"name"` + Artwork struct { + BrandWatermarkBottomRight struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.watermark.bottom.right"` + BrandLogoBottomRight struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.logo.bottom.right"` + } `json:"artwork"` + } `json:"primary_branding"` + ShortSubtitle struct { + Text string `json:"text"` + Index []interface{} `json:"index"` + } `json:"short_subtitle"` + } `json:"visuals"` + Actions struct { + Browse struct { + TargetType string `json:"target_type"` + TargetID string `json:"target_id"` + TargetName string `json:"target_name"` + TargetTheme string `json:"target_theme"` + Params struct { + } `json:"params"` + Href string `json:"href"` + BrowseTheme string `json:"browse_theme"` + MetricsInfo struct { + ActionType string `json:"action_type"` + TargetID string `json:"target_id"` + TargetType string `json:"target_type"` + TargetDisplayName string `json:"target_display_name"` + } `json:"metrics_info"` + Type string `json:"type"` + } `json:"browse"` + ContextMenu struct { + Actions []struct { + ActionType string `json:"action_type"` + EntityName string `json:"entity_name"` + EntityType string `json:"entity_type"` + MetricsInfo struct { + TargetID string `json:"target_id"` + TargetType string `json:"target_type"` + TargetDisplayName string `json:"target_display_name"` + Eab string `json:"eab"` + Type string `json:"_type"` + } `json:"metrics_info"` + Eab string `json:"eab"` + } `json:"actions"` + Header struct { + Title string `json:"title"` + Artwork struct { + Type string `json:"_type"` + Horizontal struct { + Type string `json:"_type"` + ArtworkType string `json:"artwork_type"` + Image struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageID string `json:"image_id"` + } `json:"image"` + Text string `json:"text"` + } `json:"horizontal"` + Vertical struct { + Type string `json:"_type"` + ArtworkType string `json:"artwork_type"` + Text string `json:"text"` + } `json:"vertical"` + } `json:"artwork"` + PrimaryBranding struct { + ID string `json:"id"` + Name string `json:"name"` + Artwork struct { + BrandWatermarkBottomRight struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.watermark.bottom.right"` + BrandLogoBottomRight struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.logo.bottom.right"` + } `json:"artwork"` + } `json:"primary_branding"` + Action struct { + ActionType string `json:"action_type"` + EntityName string `json:"entity_name"` + EntityType string `json:"entity_type"` + MetricsInfo struct { + TargetID string `json:"target_id"` + TargetType string `json:"target_type"` + TargetDisplayName string `json:"target_display_name"` + Eab string `json:"eab"` + Type string `json:"_type"` + } `json:"metrics_info"` + Browse struct { + TargetType string `json:"target_type"` + TargetID string `json:"target_id"` + TargetTheme string `json:"target_theme"` + Params struct { + } `json:"params"` + Type string `json:"type"` + } `json:"browse"` + TargetName string `json:"target_name"` + Href string `json:"href"` + } `json:"action"` + } `json:"header"` + } `json:"context_menu"` + } `json:"actions"` + EntityMetadata struct { + GenreNames []string `json:"genre_names"` + PremiereDate time.Time `json:"premiere_date"` + Rating struct { + Code string `json:"code"` + } `json:"rating"` + TargetName string `json:"target_name"` + IsWarm bool `json:"is_warm"` + } `json:"entity_metadata"` + } `json:"results"` + } `json:"groups"` + Metadata struct { + SearchResultType string `json:"search_result_type"` + Explanation string `json:"explanation"` + SelectionTrackingID string `json:"selection_tracking_id"` + } `json:"metadata"` + DeviceContextFailure bool `json:"device_context_failure"` +} + +type Season struct { + Type string `json:"_type"` + ID string `json:"id"` + Href string `json:"href"` + P13NHref string `json:"p13n_href"` + Name string `json:"name"` + Theme string `json:"theme"` + Artwork struct { + } `json:"artwork"` + DeviceContextFailure bool `json:"device_context_failure"` + Items []struct { + Type string `json:"_type"` + ID string `json:"id"` + Href string `json:"href"` + Name string `json:"name"` + Description string `json:"description"` + Artwork struct { + VideoHorizontalHero struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"video.horizontal.hero"` + } `json:"artwork"` + MetricsInfo struct { + Type string `json:"_type"` + MetricsAssetName string `json:"metrics_asset_name"` + AiringType string `json:"airing_type"` + ExternalIdentifiers []struct { + Namespace string `json:"namespace"` + ID string `json:"id"` + } `json:"external_identifiers"` + } `json:"metrics_info"` + Personalization struct { + Eab string `json:"eab"` + } `json:"personalization"` + DeviceContextFailure bool `json:"device_context_failure"` + Browse struct { + TargetType string `json:"target_type"` + TargetID string `json:"target_id"` + TargetTheme string `json:"target_theme"` + Params struct { + } `json:"params"` + Href string `json:"href"` + BrowseTheme string `json:"browse_theme"` + Type string `json:"type"` + } `json:"browse"` + SeriesID string `json:"series_id"` + SeriesName string `json:"series_name"` + Season string `json:"season"` + SeasonShortDisplayName string `json:"season_short_display_name"` + Bundle struct { + Type string `json:"_type"` + ID int `json:"id"` + EabID string `json:"eab_id"` + NetworkID string `json:"network_id"` + NetworkName string `json:"network_name"` + Duration int `json:"duration"` + Availability struct { + Type string `json:"_type"` + StartDate time.Time `json:"start_date"` + EndDate time.Time `json:"end_date"` + LocationRequirement string `json:"location_requirement"` + IsAvailable bool `json:"is_available"` + } `json:"availability"` + BundleType string `json:"bundle_type"` + Rating string `json:"rating"` + OpenCreditEndPos int `json:"open_credit_end_pos"` + CloseCreditStartPos int `json:"close_credit_start_pos"` + Rights struct { + Startover bool `json:"startover"` + Recordable bool `json:"recordable"` + Offline bool `json:"offline"` + ClientOverride bool `json:"client_override"` + } `json:"rights"` + CpID int `json:"cp_id"` + AllEtag string `json:"all_etag"` + RightsEtag string `json:"rights_etag"` + AiringsEtag string `json:"airings_etag"` + StreamEtag string `json:"stream_etag"` + RightsTTL int `json:"rights_ttl"` + AiringsTTL int `json:"airings_ttl"` + StreamTTL int `json:"stream_ttl"` + PackageID int `json:"package_id"` + AvFeatures []string `json:"av_features"` + } `json:"bundle"` + Number string `json:"number"` + PrimaryBranding struct { + ID string `json:"id"` + Name string `json:"name"` + Artwork struct { + BrandWatermark struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.watermark"` + BrandWatermarkDark struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.watermark.dark"` + BrandWatermarkTopRight struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.watermark.top.right"` + BrandLogo struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.logo"` + NetworkTile struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"network.tile"` + BrandWatermarkBottomRight struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.watermark.bottom.right"` + BrandLogoTopRight struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.logo.top.right"` + BrandLogoBottomRight struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"brand.logo.bottom.right"` + } `json:"artwork"` + } `json:"primary_branding"` + Rating struct { + Code string `json:"code"` + } `json:"rating"` + GenreNames []string `json:"genre_names"` + PremiereDate time.Time `json:"premiere_date"` + Duration int `json:"duration"` + IsFirstRun bool `json:"is_first_run"` + SeriesArtwork struct { + DetailVerticalHero struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"detail.vertical.hero"` + TitleTreatmentHorizontal struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"title.treatment.horizontal"` + ProgramTile struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"program.tile"` + ProgramVerticalTile struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"program.vertical.tile"` + TitleTreatmentStacked struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"title.treatment.stacked"` + DetailHorizontalHero struct { + Path string `json:"path"` + Accent struct { + Hue int `json:"hue"` + Classification string `json:"classification"` + } `json:"accent"` + ImageType string `json:"image_type"` + ImageID string `json:"image_id"` + } `json:"detail.horizontal.hero"` + } `json:"series_artwork"` + RestrictionLevel string `json:"restriction_level"` + Exclusivity string `json:"exclusivity"` + Actions []interface{} `json:"actions"` + } `json:"items"` + Pagination struct { + CurrentOffset int `json:"current_offset"` + TotalCount int `json:"total_count"` + } `json:"pagination"` + SeriesGroupingMetadata struct { + SeriesGroupingType string `json:"series_grouping_type"` + SeasonNumber int `json:"season_number"` + GroupingName string `json:"groupingName"` + Unknown bool `json:"unknown"` + } `json:"series_grouping_metadata"` +} + +type PlaybackInformation struct { + Type string `json:"_type"` + Browse struct { + TargetType string `json:"target_type"` + TargetID string `json:"target_id"` + TargetTheme string `json:"target_theme"` + Params struct { + } `json:"params"` + Type string `json:"type"` + } `json:"browse"` + EabID string `json:"eab_id"` + Href string `json:"href"` + ID string `json:"id"` + HrefType string `json:"href_type"` + RestrictionLevel string `json:"restriction_level"` +} + +type PlaylistRequest struct { + DeviceIdentifier string `json:"device_identifier"` + DeejayDeviceID int `json:"deejay_device_id"` + Version int `json:"version"` + AllCdn bool `json:"all_cdn"` + ContentEabID string `json:"content_eab_id"` + Region string `json:"region"` + XlinkSupport bool `json:"xlink_support"` + DeviceAdID string `json:"device_ad_id"` + LimitAdTracking bool `json:"limit_ad_tracking"` + IgnoreKidsBlock bool `json:"ignore_kids_block"` + Language string `json:"language"` + GUID string `json:"guid"` + Rv int `json:"rv"` + Kv int `json:"kv"` + Unencrypted bool `json:"unencrypted"` + IncludeT2RevenueBeacon string `json:"include_t2_revenue_beacon"` + CpSessionID string `json:"cp_session_id"` + InterfaceVersion string `json:"interface_version"` + NetworkMode string `json:"network_mode"` + PlayIntent string `json:"play_intent"` + Playback PlaylistRequestPlayback `json:"playback"` +} + +type PlaylistRequestValues struct { + Type string `json:"type,omitempty"` + Profile string `json:"profile,omitempty"` + Level string `json:"level,omitempty"` + Framerate int `json:"framerate,omitempty"` + Version string `json:"version,omitempty"` + SecurityLevel string `json:"security_level,omitempty"` + Encryption *PlaylistRequestEncryption `json:"encryption,omitempty"` + HTTPS bool `json:"https,omitempty"` +} + +type PlaylistRequestCodecs struct { + Values []PlaylistRequestValues `json:"values"` + SelectionMode string `json:"selection_mode"` +} + +type PlaylistRequestVideo struct { + Codecs PlaylistRequestCodecs `json:"codecs"` +} + +type PlaylistRequestAudio struct { + Codecs PlaylistRequestCodecs `json:"codecs"` +} + +type PlaylistRequestDRM struct { + Values []PlaylistRequestValues `json:"values"` + SelectionMode string `json:"selection_mode"` +} + +type PlaylistRequestManifest struct { + Type string `json:"type"` + HTTPS bool `json:"https"` + MultipleCdns bool `json:"multiple_cdns"` + PatchUpdates bool `json:"patch_updates"` + HuluTypes bool `json:"hulu_types"` + LiveDai bool `json:"live_dai"` + MultiplePeriods bool `json:"multiple_periods"` + Xlink bool `json:"xlink"` + SecondaryAudio bool `json:"secondary_audio"` + LiveFragmentDelay int `json:"live_fragment_delay"` +} + +type PlaylistRequestEncryption struct { + Mode string `json:"mode"` + Type string `json:"type"` +} + +type PlaylistRequestSegments struct { + Values []PlaylistRequestValues `json:"values"` + SelectionMode string `json:"selection_mode"` +} + +type PlaylistRequestPlayback struct { + Version int `json:"version"` + Video PlaylistRequestVideo `json:"video"` + Audio PlaylistRequestAudio `json:"audio"` + DRM PlaylistRequestDRM `json:"drm"` + Manifest PlaylistRequestManifest `json:"manifest"` + Segments PlaylistRequestSegments `json:"segments"` +} +type Playlist struct { + UseManifestBreaks bool `json:"use_manifest_breaks"` + Adstate string `json:"adstate"` + Breaks []interface{} `json:"breaks"` + ContentEabID string `json:"content_eab_id"` + TranscriptsUrls struct { + Smi struct { + En string `json:"en"` + } `json:"smi"` + Webvtt struct { + En string `json:"en"` + } `json:"webvtt"` + Ttml struct { + En string `json:"en"` + } `json:"ttml"` + } `json:"transcripts_urls"` + TranscriptsEncryptionKey string `json:"transcripts_encryption_key"` + VideoMetadata struct { + AspectRatio string `json:"aspect_ratio"` + EndCreditsTime string `json:"end_credits_time"` + FrameRate int `json:"frame_rate"` + HasBug string `json:"has_bug"` + HasCaptions bool `json:"has_captions"` + HasNetworkPreRoll bool `json:"has_network_pre_roll"` + Interstitials string `json:"interstitials"` + Language string `json:"language"` + Length int `json:"length"` + Segments string `json:"segments"` + ID int `json:"id"` + AssetID int `json:"asset_id"` + Markers interface{} `json:"markers"` + TranscriptsDefaultOn bool `json:"transcripts_default_on"` + RatingBugBig string `json:"rating_bug_big"` + RatingBugSmall string `json:"rating_bug_small"` + } `json:"video_metadata"` + TranscriptsEncryptionIv string `json:"transcripts_encryption_iv"` + Breakhash string `json:"breakhash"` + AdBreakTimes []int `json:"ad_break_times"` + TranscriptsDefaultOn bool `json:"transcripts_default_on"` + ResumePosition int `json:"resume_position"` + RecordingOffset int `json:"recording_offset"` + InitialPosition int `json:"initial_position"` + DashPrServer string `json:"dash_pr_server"` + WvServer string `json:"wv_server"` + AudioTracks []struct { + Language string `json:"language"` + Role string `json:"role"` + CodecsString string `json:"codecs_string"` + Channels int `json:"channels"` + } `json:"audio_tracks"` + MbrManifest string `json:"mbr_manifest"` + StreamURL string `json:"stream_url"` + ThumbnailEndpoint string `json:"thumbnail_endpoint"` + AssetPlaybackType string `json:"asset_playback_type"` + SauronID string `json:"sauron_id"` + ViewTTLMillis int `json:"view_ttl_millis"` + SauronToken string `json:"sauron_token"` + SauronTokenTTL int `json:"sauron_token_ttl"` + SauronTokenTTLMs int `json:"sauron_token_ttl_ms"` +} + +type Config struct { + PassThroughQos string `json:"pass_through_qos"` + Kinko string `json:"kinko"` + PackageID int `json:"package_id"` + API string `json:"api"` + QosBeacon string `json:"qos_beacon"` + NielsenAppName string `json:"nielsen_app_name"` + FeedbackCategory int `json:"feedbackCategory"` + PlusPlanID int `json:"plus_plan_id"` + FirehoseEndpoint string `json:"firehose_endpoint"` + PbAutoresumeTimeout int `json:"pb_autoresume_timeout"` + SashProductDescription string `json:"sash_product_description"` + PlaylistEndpoint string `json:"playlist_endpoint"` + NielsenAppID string `json:"nielsen_app_id"` + PackageGroupID int `json:"package_group_id"` + FlexActionEndpoint string `json:"flex_action_endpoint"` + PlaybackRequestTimeout int `json:"playback_request_timeout"` + Asset string `json:"asset"` + NoahSignupExceptionMessage []string `json:"noah_signup_exception_message"` + PbInterval int `json:"pb_interval"` + PackageGroupIDFrontPorch int `json:"package_group_id_front_porch"` + FlagsContext struct { + FlagStateValid bool `json:"flag_state_valid"` + UILink string `json:"ui_link"` + Key string `json:"key"` + SealTokenState string `json:"seal_token_state"` + } `json:"flags_context"` + SashProductTitle string `json:"sash_product_title"` + TrackTiersDeepPlayerState int `json:"track_tiers_deep_player_state"` + UserAccountURL string `json:"userAccountURL"` + Pgid int `json:"pgid"` + GeokResponse string `json:"geok_response"` + UserInfoURL string `json:"user_info_url"` + ChangePlanURL string `json:"changePlanURL"` + Profiles struct { + PromptAfterIdleMs int `json:"prompt_after_idle_ms"` + } `json:"profiles"` + AutoplayIdleTimeout int `json:"autoplay_idle_timeout"` + NielsenSfCode string `json:"nielsen_sf_code"` + PlusLandingURL string `json:"plusLandingURL"` + NielsenAppVersion string `json:"nielsen_app_version"` + PlayerProgressReportInterval int `json:"player_progress_report_interval"` + ProductInstrumentationV2 struct { + MetricsAgent struct { + Endpoint string `json:"endpoint"` + MaxHitRetries int `json:"max_hit_retries"` + SamplingRatios struct { + ServiceCall float64 `json:"service_call"` + } `json:"sampling_ratios"` + MsPerEvent int `json:"ms_per_event"` + Enabled bool `json:"enabled"` + MaxHitQueueMs int `json:"max_hit_queue_ms"` + EventFilterConfig struct { + } `json:"event_filter_config"` + OnlineAssetMaxBeaconQueueMs int `json:"online_asset_max_beacon_queue_ms"` + DownloadedAssetMaxBeaconQueueMs int `json:"downloaded_asset_max_beacon_queue_ms"` + EventWhitelist []string `json:"event_whitelist"` + NonInteractiveEvents []string `json:"non_interactive_events"` + BucketSize int `json:"bucket_size"` + } `json:"metrics_agent"` + ConvivaAgent struct { + FatalErrors []string `json:"fatal_errors"` + Staging bool `json:"staging"` + Token string `json:"token"` + Enabled bool `json:"enabled"` + GatewayURL string `json:"gateway_url"` + } `json:"conviva_agent"` + MetricsTracker struct { + } `json:"metrics_tracker"` + RateLimiting struct { + SegmentDownloadHit int `json:"segment_download_hit"` + } `json:"rate_limiting"` + AdobeAgent struct { + AppMeasurementTrackingServer string `json:"app_measurement_tracking_server"` + VisitorMcid string `json:"visitor_mcid"` + Enabled bool `json:"enabled"` + AppMeasurementRsid string `json:"app_measurement_rsid"` + VisitorTrackingServer string `json:"visitor_tracking_server"` + HeartbeatTrackingServer string `json:"heartbeat_tracking_server"` + } `json:"adobe_agent"` + MoatAgent struct { + Enabled bool `json:"enabled"` + } `json:"moat_agent"` + AdobeAgentV2 struct { + AppMeasurementTrackingServer string `json:"app_measurement_tracking_server"` + VisitorMcid string `json:"visitor_mcid"` + Enabled bool `json:"enabled"` + AppMeasurementRsid string `json:"app_measurement_rsid"` + VisitorTrackingServer string `json:"visitor_tracking_server"` + HeartbeatTrackingServer string `json:"heartbeat_tracking_server"` + } `json:"adobe_agent_v2"` + } `json:"product_instrumentation_v2"` + FeedbackURL string `json:"feedbackURL"` + IsAnonProxy bool `json:"is_anon_proxy"` + NielsenEnabled string `json:"nielsen_enabled"` + EurekaNamespace string `json:"eureka_namespace"` + ReportGeocheckURL string `json:"reportGeocheckURL"` + PbTracker string `json:"pb_tracker"` + MetricsAgent struct { + MaxBatchesBuffered int `json:"max_batches_buffered"` + MaxBatchSize int `json:"max_batch_size"` + Enabled bool `json:"enabled"` + EventFilterConfig struct { + ServiceCall struct { + EventRules []struct { + RuleType string `json:"rule_type"` + RuleFilter struct { + Type string `json:"type,omitempty"` + Dimension string `json:"dimension,omitempty"` + Value string `json:"value,omitempty"` + Filters []struct { + Type string `json:"type,omitempty"` + Dimension string `json:"dimension,omitempty"` + Value string `json:"value,omitempty"` + } `json:"filters,omitempty"` + } `json:"rule_filter,omitempty"` + } `json:"event_rules"` + } `json:"service_call"` + Log struct { + EventRules []struct { + RuleType string `json:"rule_type"` + RuleFilter struct { + Filter struct { + Type string `json:"type"` + Filters []struct { + Type string `json:"type"` + Dimension string `json:"dimension"` + Value string `json:"value"` + } `json:"filters"` + } `json:"filter"` + Type string `json:"type"` + } `json:"rule_filter"` + } `json:"event_rules"` + } `json:"log"` + } `json:"event_filter_config"` + Endpoint string `json:"endpoint"` + FlushInterval int `json:"flush_interval"` + } `json:"metrics_agent"` + Iball string `json:"iball"` + HuluMbr string `json:"hulu_mbr"` + NoahSignupExceptionShows []struct { + ID int `json:"id"` + Title string `json:"title"` + } `json:"noah_signup_exception_shows"` + BeaconConfig string `json:"beacon_config"` + Sapi string `json:"sapi"` + Csel string `json:"csel"` + ProfileBitrates []int `json:"profile_bitrates"` + PlusLearnMoreURL string `json:"plusLearnMoreURL"` + NoahProductDescription string `json:"noah_product_description"` + SauronAccessToken string `json:"sauron_access_token"` + EurekaApplicationID string `json:"eureka_application_id"` + GeokLocation string `json:"geok_location"` + PlusInviteURL string `json:"plusInviteURL"` + HothHost string `json:"hoth_host"` + PlaybackRequestRetries int `json:"playback_request_retries"` + BadgingConfig []struct { + Text string `json:"text"` + State string `json:"state"` + Style string `json:"style"` + } `json:"badging_config"` + AdServer string `json:"ad_server"` + RtBeacon string `json:"rt_beacon"` + EndpointUrls struct { + PlaylistV4 string `json:"playlist_v4"` + PlaylistV5 string `json:"playlist_v5"` + PlaylistV6 string `json:"playlist_v6"` + UserStateV5 string `json:"user_state_v5"` + WatchDownloadV1 string `json:"watch_download_v1"` + DvrRecordingsV1 string `json:"dvr_recordings_v1"` + UserV1 string `json:"user_v1"` + FlexActionV1 string `json:"flex_action_v1"` + BrowseV5 string `json:"browse_v5"` + UserBookmarksV1 string `json:"user_bookmarks_v1"` + GuideV0 string `json:"guide_v0"` + UserTastesV5 string `json:"user_tastes_v5"` + VortexV0 string `json:"vortex_v0"` + ConvivaV0 string `json:"conviva_v0"` + DvrRecordingSettingsV1 string `json:"dvr_recording_settings_v1"` + DvrV1 string `json:"dvr_v1"` + ConfigV0 string `json:"config_v0"` + EmuV0 string `json:"emu_v0"` + SauronV1 string `json:"sauron_v1"` + PlaybackFeaturesV0 string `json:"playback_features_v0"` + OfflinePlaylistV1 string `json:"offline_playlist_v1"` + AuthV1 string `json:"auth_v1"` + AuthV2 string `json:"auth_v2"` + OnboardingV5 string `json:"onboarding_v5"` + AuthAppleAuthnRequestV0 string `json:"auth_apple_authn_request_v0"` + GlobalNavV1 string `json:"global_nav_v1"` + } `json:"endpoint_urls"` + IapGracefulDegradationEnabled bool `json:"iap_graceful_degradation_enabled"` + KeyExpiration int `json:"key_expiration"` + Beacon string `json:"beacon"` + Key string `json:"key"` + EurekaApplicationName string `json:"eureka_application_name"` + DeviceID int `json:"device_id"` + PackageIDFrontPorch int `json:"package_id_front_porch"` + PlaybackFeaturesEndpoint string `json:"playback_features_endpoint"` + NoahSignupExceptionURL string `json:"noah_signup_exception_url"` + ExpirationNoticeHours int `json:"expiration_notice_hours"` + ForgotPasswordURL string `json:"forgotPasswordURL"` + SauronEndpoint string `json:"sauron_endpoint"` + GlobalNavEndpoint string `json:"global_nav_endpoint"` + PassThroughMetric string `json:"pass_through_metric"` + BanyaSec string `json:"banya_sec"` + Nydus string `json:"nydus"` + Flags struct { + HuluClientStandardPromptTheme bool `json:"hulu-client-standard-prompt-theme"` + HuluClientTwoFactorVerify bool `json:"hulu-client-two-factor-verify"` + HuluClientGatewayDeviceRanking bool `json:"hulu-client-gateway-device-ranking"` + HuluWebDemoPlayerVersion struct { + HitchMobilePlaybackProdHuluCom string `json:"hitch-mobile-playback.prod.hulu.com"` + CoviewingProdHuluCom string `json:"coviewing.prod.hulu.com"` + EndcardProdHuluCom string `json:"endcard.prod.hulu.com"` + LocalhostProdHuluCom string `json:"localhost.prod.hulu.com"` + OneplayerProdHuluCom string `json:"oneplayer.prod.hulu.com"` + DevelopProdHuluCom string `json:"develop.prod.hulu.com"` + } `json:"hulu-web-demo-player-version"` + HuluWebChromecastSdkPlayerVersion struct { + Player string `json:"player"` + Options struct { + MultiKey bool `json:"multi-key"` + Hdr bool `json:"hdr"` + Touchstone bool `json:"touchstone"` + } `json:"options"` + Sdk string `json:"sdk"` + } `json:"hulu-web-chromecast-sdk-player-version"` + HuluClientRokuInstantSignupEnabled bool `json:"hulu-client-roku-instant-signup-enabled"` + HuluClientEndCardFg1 bool `json:"hulu-client-end-card-fg1"` + HuluClientPinProtectionEnabled bool `json:"hulu-client-pin-protection-enabled"` + HuluClientPerformanceTracking bool `json:"hulu-client-performance-tracking"` + HuluWebSmokeSitePlayerVersion struct { + Nonsub string `json:"nonsub"` + Sub string `json:"sub"` + } `json:"hulu-web-smoke-site-player-version"` + HuluWebSmokeChromecastSdkPlayerVersion struct { + Player string `json:"player"` + Options struct { + MultipleKey bool `json:"multiple-key"` + MultiKey bool `json:"multi-key"` + Touchstone bool `json:"touchstone"` + } `json:"options"` + Sdk string `json:"sdk"` + } `json:"hulu-web-smoke-chromecast-sdk-player-version"` + HuluClientNeverBlockSvodEnabled bool `json:"hulu-client-never-block-svod-enabled"` + HuluClientUpdatedLocationPrompt bool `json:"hulu-client-updated-location-prompt"` + HuluClientFlexWelcomeEnabled bool `json:"hulu-client-flex-welcome-enabled"` + HuluClientEventPurchaseEnabled bool `json:"hulu-client-event-purchase-enabled"` + HuluWebDevelopProdSitePlayerOptions struct { + CreditEndCardDuration string `json:"credit_end_card_duration"` + SkipButtonDuration string `json:"skip_button_duration"` + EnablePinchZoom bool `json:"enable_pinch_zoom"` + EnabledAdobeAgent bool `json:"enabled_adobe_agent"` + EnabledQueuedSeek bool `json:"enabled_queued_seek"` + } `json:"hulu-web-develop-prod-site-player-options"` + HuluClientExperienceBrandedPageThemeSupport string `json:"hulu-client-experience-branded-page-theme-support"` + HuluClientSignupOnDeviceEnabled bool `json:"hulu-client-signup-on-device-enabled"` + HuluClientNonNumericSeasons bool `json:"hulu-client-non-numeric-seasons"` + HuluClientFlexTimeoutsMs int `json:"hulu-client-flex-timeouts-ms"` + HuluClientDvrRecordingsGroups bool `json:"hulu-client-dvr-recordings-groups"` + HuluClientPlayerBasicsFg1 bool `json:"hulu-client-player-basics-fg-1"` + HuluClientEventPurchasePollingTimeout int `json:"hulu-client-event-purchase-polling-timeout"` + HuluClientNewDvrFeatures bool `json:"hulu-client-new-dvr-features"` + HuluClientFeatureMultikey bool `json:"hulu-client-feature-multikey"` + HuluClientPostPurchaseCollectionID int `json:"hulu-client-post-purchase-collection-id"` + HuluClientPlanSelectExtraCopy struct { + ShowExtraCopy bool `json:"showExtraCopy"` + } `json:"hulu-client-plan-select-extra-copy"` + HuluWebSmokeChromecastPlayerOptions struct { + Touchstone bool `json:"touchstone"` + } `json:"hulu-web-smoke-chromecast-player-options"` + HuluClientCompassViewAllEnabled bool `json:"hulu-client-compass-view-all-enabled"` + HuluClientForcedDcsCapabilities []string `json:"hulu-client-forced-dcs-capabilities"` + HuluWebSitePlayerOptions struct { + CreditEndCardDuration string `json:"credit_end_card_duration"` + EnabledBrightline bool `json:"enabled_brightline"` + EnabledAdobeAgent bool `json:"enabled_adobe_agent"` + EnabledQueuedSeek bool `json:"enabled_queued_seek"` + } `json:"hulu-web-site-player-options"` + HuluClientInAppAccountManagementAddOnsEnabled bool `json:"hulu-client-in-app-account-management-add-ons-enabled"` + HuluClientCompassEnabled bool `json:"hulu-client-compass-enabled"` + HuluClientFeaturePxsSurveyEnabled bool `json:"hulu-client-feature-pxs-survey-enabled"` + HuluClientTrailheadBannerTheme bool `json:"hulu-client-trailhead-banner-theme"` + HuluClientAvMetadataBadgingEnabled bool `json:"hulu-client-av-metadata-badging-enabled"` + HuluClientIdleTimeMs int `json:"hulu-client-idle-time-ms"` + HuluWebDevelopProdSitePlayerVersion struct { + Nonsub string `json:"nonsub"` + Sub string `json:"sub"` + } `json:"hulu-web-develop-prod-site-player-version"` + HuluClientPlayerProgressReportInterval int `json:"hulu-client-player-progress-report-interval"` + HuluClientDeviceTokenLoggingEnabled bool `json:"hulu-client-device-token-logging-enabled"` + HuluClientInAppAccountManagementEnabled bool `json:"hulu-client-in-app-account-management-enabled"` + HuluClientEventPurchaseIdentityVerificationPollingInterval int `json:"hulu-client-event-purchase-identity-verification-polling-interval"` + HuluClientCheckProgramRecordability bool `json:"hulu-client-check-program-recordability"` + HuluClientAutoAccountLinkEnabled bool `json:"hulu-client-auto-account-link-enabled"` + HuluWebSmokeSitePlayerOptions struct { + CreditEndCardDuration string `json:"credit_end_card_duration"` + EnabledAdobeAgent bool `json:"enabled_adobe_agent"` + EnabledQueuedSeek bool `json:"enabled_queued_seek"` + } `json:"hulu-web-smoke-site-player-options"` + HuluClientFliptray2 bool `json:"hulu-client-fliptray-2"` + HuluClientOneplayer bool `json:"hulu-client-oneplayer"` + HuluClientFeaturePxsSurveyConfig struct { + PxsShowPercentage float64 `json:"pxs_show_percentage"` + PxsAutoDismissSeconds int `json:"pxs_auto_dismiss_seconds"` + PxsShowFrequencyDays int `json:"pxs_show_frequency_days"` + } `json:"hulu-client-feature-pxs-survey-config"` + HuluWebBrowseFlags struct { + EditorialActionsEnabled bool `json:"editorialActionsEnabled"` + ContextMenuActionV2Enabled bool `json:"contextMenuActionV2Enabled"` + VideoTileEnabled bool `json:"videoTileEnabled"` + EnableWebp bool `json:"enableWebp"` + VariationName string `json:"variationName"` + } `json:"hulu-web-browse-flags"` + HuluClientDetailsCastAndCrew bool `json:"hulu-client-details-cast-and-crew"` + HuluClientPlanSelectChartEnabled bool `json:"hulu-client-plan-select-chart-enabled"` + HuluClientEndpointURLConfiguration bool `json:"hulu-client-endpoint-url-configuration"` + HuluClientDvrMsbd bool `json:"hulu-client-dvr-msbd"` + HuluClientMyStuffDecoupled bool `json:"hulu-client-my-stuff-decoupled"` + HuluWebSitePlayerVersion struct { + Nonsub string `json:"nonsub"` + Sub string `json:"sub"` + } `json:"hulu-web-site-player-version"` + HuluClientTealiumEventsEnabled bool `json:"hulu-client-tealium-events-enabled"` + HuluWebChromecastPlayerOptions struct { + OverrideAdUnits string `json:"overrideAdUnits"` + Touchstone bool `json:"touchstone"` + } `json:"hulu-web-chromecast-player-options"` + HuluClientEventPurchasePollingBaseInterval int `json:"hulu-client-event-purchase-polling-base-interval"` + HuluClientBrandedCollections bool `json:"hulu-client-branded-collections"` + HuluClientSignupOnWebEnabled bool `json:"hulu-client-signup-on-web-enabled"` + HuluClientCompassSitemapEnabled bool `json:"hulu-client-compass-sitemap-enabled"` + HuluClientAdobeMetrics bool `json:"hulu-client-adobe-metrics"` + HuluClientGatewayAdLegalDisclaimer string `json:"hulu-client-gateway-ad-legal-disclaimer"` + HuluClientFeatureChannelFlipping bool `json:"hulu-client-feature-channel-flipping"` + HuluClientFeaturePlaybackCdnSorting bool `json:"hulu-client-feature-playback-cdn-sorting"` + HuluClientLoginMfa bool `json:"hulu-client-login-mfa"` + HuluClientLinksharingAppsflyer bool `json:"hulu-client-linksharing-appsflyer"` + HuluClientFeatureHdr bool `json:"hulu-client-feature-hdr"` + } `json:"flags"` + NoahProductTitle string `json:"noah_product_title"` + CriterionCollection int `json:"criterion_collection"` + KeyID int `json:"key_id"` +} diff --git a/main.go b/main.go new file mode 100644 index 0000000..2231228 --- /dev/null +++ b/main.go @@ -0,0 +1,170 @@ +package main + +import ( + "bytes" + "encoding/hex" + "fmt" + "github.com/chris124567/hulu/hulu" + "github.com/chris124567/hulu/widevine" + "io" + "lukechampine.com/flagg" + "net/http" + "os" + "text/tabwriter" + "time" +) + +func main() { + rootCmd := flagg.Root + rootCmd.Usage = flagg.SimpleUsage(rootCmd, `Hulu Downloader +It is necessary to specify the HULU_SESSION environment variable because the Hulu API requires this for all requests. + +Subcommands: +search [query] - searches Hulu with the provided query and returns titles and their Hulu IDs +season [id] [season number] - lists episode title and IDs of a given show and season +download [id] - prints the MPD url the video is available at and returns the mp4decrypt command necessary to decrypt it +`) + + searchCmd := flagg.New("search", "Search Hulu for a movie or series.") + searchQuery := searchCmd.String("query", "", "Search query.") + + seasonCmd := flagg.New("season", "Get information about season in a show by its show ID and season number.") + seasonID := seasonCmd.String("id", "", "ID of series.") + seasonNumber := seasonCmd.Int("number", 1, "Season number.") + + downloadCmd := flagg.New("download", "Download a show episode or movie by its ID.") + downloadID := downloadCmd.String("id", "", "ID of movie or episode.") + + tree := flagg.Tree{ + Cmd: rootCmd, + Sub: []flagg.Tree{ + {Cmd: searchCmd}, + {Cmd: seasonCmd}, + {Cmd: downloadCmd}, + }, + } + cmd := flagg.Parse(tree) + + huluSession := os.Getenv("HULU_SESSION") + if huluSession == "" { + rootCmd.Usage() + return + } + // panic(huluSession) + + client := hulu.NewDefaultClient(huluSession) + w := tabwriter.NewWriter(os.Stdout, 8, 8, 0, '\t', 0) + defer w.Flush() + + switch cmd { + case searchCmd: + if !flagg.IsDefined(cmd, "query") { + cmd.Usage() + return + } + results, err := client.Search(*searchQuery) + if err != nil { + panic(err) + } + fmt.Fprintf(w, "%s\t%s\t\n", "Title", "ID") + for _, group := range results.Groups { + for _, result := range group.Results { + fmt.Fprintf(w, "%s\t%s\n", result.Visuals.Headline.Text, result.MetricsInfo.TargetID) + } + } + case seasonCmd: + if !flagg.IsDefined(cmd, "id") || !flagg.IsDefined(cmd, "number") { + cmd.Usage() + return + } + results, err := client.Season(*seasonID, *seasonNumber) + if err != nil { + panic(err) + } + fmt.Fprintf(w, "%s\t%s\t\n", "Title", "ID") + for _, item := range results.Items { + fmt.Fprintf(w, "%s\t%s\t\n", item.Name, item.ID) + } + case downloadCmd: + if !flagg.IsDefined(cmd, "id") { + cmd.Usage() + return + } + + playbackInformation, err := client.PlaybackInformation(*downloadID) + if err != nil { + panic(err) + } + + serverConfig, err := client.ServerConfig() + if err != nil { + panic(err) + } + + playlist, err := client.Playlist(serverConfig.KeyID, playbackInformation.EabID) + if err != nil { + panic(err) + } + + client := &http.Client{ + Timeout: 10 * time.Second, + } + + // request MPD file + response, err := client.Get(playlist.StreamURL) + if err != nil { + panic(err) + } + defer response.Body.Close() + + // parse init data/PSSH from XML + initData, err := widevine.InitDataFromMPD(response.Body) + if err != nil { + panic(err) + } + + cdm, err := widevine.NewDefaultCDM(initData) + if err != nil { + panic(err) + } + + licenseRequest, err := cdm.GetLicenseRequest() + if err != nil { + panic(err) + } + + request, err := http.NewRequest(http.MethodPost, playlist.WvServer, bytes.NewReader(licenseRequest)) + if err != nil { + panic(err) + } + // hulu actually checks for headers here so this is necessary + request.Header = hulu.StandardHeaders() + request.Close = true + // send license request to license server + response, err = client.Do(request) + if err != nil { + panic(err) + } + defer response.Body.Close() + licenseResponse, err := io.ReadAll(response.Body) + if err != nil { + panic(err) + } + + // parse keys from response + keys, err := cdm.GetLicenseKeys(licenseRequest, licenseResponse) + if err != nil { + panic(err) + } + + command := "mp4decrypt input.mp4 output.mp4" + for _, key := range keys { + if key.Type == widevine.License_KeyContainer_CONTENT { + command += " --key " + hex.EncodeToString(key.ID) + ":" + hex.EncodeToString(key.Value) + } + } + fmt.Println("MPD URL: ", playlist.StreamURL) + fmt.Println("Decryption command: ", command) + return + } +} diff --git a/proto/wv_proto2.proto b/proto/wv_proto2.proto new file mode 100644 index 0000000..1396a2c --- /dev/null +++ b/proto/wv_proto2.proto @@ -0,0 +1,468 @@ +syntax = "proto2"; + +option go_package = ".;widevine"; + +// from x86 (partial), most of it from the ARM version: +message ClientIdentification { + enum TokenType { + KEYBOX = 0; + DEVICE_CERTIFICATE = 1; + REMOTE_ATTESTATION_CERTIFICATE = 2; + } + message NameValue { + required string Name = 1; + required string Value = 2; + } + message ClientCapabilities { + enum HdcpVersion { + HDCP_NONE = 0; + HDCP_V1 = 1; + HDCP_V2 = 2; + HDCP_V2_1 = 3; + HDCP_V2_2 = 4; + } + optional uint32 ClientToken = 1; + optional uint32 SessionToken = 2; + optional uint32 VideoResolutionConstraints = 3; + optional HdcpVersion MaxHdcpVersion = 4; + optional uint32 OemCryptoApiVersion = 5; + } + required TokenType Type = 1; + //optional bytes Token = 2; // by default the client treats this as blob, but it's usually a DeviceCertificate, so for usefulness sake, I'm replacing it with this one: + optional SignedDeviceCertificate Token = 2; // use this when parsing, "bytes" when building a client id blob + repeated NameValue ClientInfo = 3; + optional bytes ProviderClientToken = 4; + optional uint32 LicenseCounter = 5; + optional ClientCapabilities _ClientCapabilities = 6; // how should we deal with duped names? will have to look at proto docs later + optional FileHashes _FileHashes = 7; // vmp blob goes here +} + +message DeviceCertificate { + enum CertificateType { + ROOT = 0; + INTERMEDIATE = 1; + USER_DEVICE = 2; + SERVICE = 3; + } + required CertificateType Type = 1; // the compiled code reused this as ProvisionedDeviceInfo.WvSecurityLevel, however that is incorrect (compiler aliased it as they're both identical as a structure) + optional bytes SerialNumber = 2; + optional uint32 CreationTimeSeconds = 3; + optional bytes PublicKey = 4; + optional uint32 SystemId = 5; + optional uint32 TestDeviceDeprecated = 6; // is it bool or int? + optional bytes ServiceId = 7; // service URL for service certificates +} + +// missing some references, +message DeviceCertificateStatus { + enum CertificateStatus { + VALID = 0; + REVOKED = 1; + } + optional bytes SerialNumber = 1; + optional CertificateStatus Status = 2; + optional ProvisionedDeviceInfo DeviceInfo = 4; // where is 3? is it deprecated? +} + +message DeviceCertificateStatusList { + optional uint32 CreationTimeSeconds = 1; + repeated DeviceCertificateStatus CertificateStatus = 2; +} + +message EncryptedClientIdentification { + required string ServiceId = 1; + optional bytes ServiceCertificateSerialNumber = 2; + required bytes EncryptedClientId = 3; + required bytes EncryptedClientIdIv = 4; + required bytes EncryptedPrivacyKey = 5; +} + +// todo: fill (for this top-level type, it might be impossible/difficult) +enum LicenseType { + ZERO = 0; + DEFAULT = 1; // 1 is STREAMING/temporary license; on recent versions may go up to 3 (latest x86); it might be persist/don't persist type, unconfirmed + OFFLINE = 2; +} + +// todo: fill (for this top-level type, it might be impossible/difficult) +// this is just a guess because these globals got lost, but really, do we need more? +enum ProtocolVersion { + CURRENT = 21; // don't have symbols for this +} + + +message LicenseIdentification { + optional bytes RequestId = 1; + optional bytes SessionId = 2; + optional bytes PurchaseId = 3; + optional LicenseType Type = 4; + optional uint32 Version = 5; + optional bytes ProviderSessionToken = 6; +} + + +message License { + message Policy { + optional bool CanPlay = 1; // changed from uint32 to bool + optional bool CanPersist = 2; + optional bool CanRenew = 3; + optional uint32 RentalDurationSeconds = 4; + optional uint32 PlaybackDurationSeconds = 5; + optional uint32 LicenseDurationSeconds = 6; + optional uint32 RenewalRecoveryDurationSeconds = 7; + optional string RenewalServerUrl = 8; + optional uint32 RenewalDelaySeconds = 9; + optional uint32 RenewalRetryIntervalSeconds = 10; + optional bool RenewWithUsage = 11; // was uint32 + } + message KeyContainer { + enum KeyType { + SIGNING = 1; + CONTENT = 2; + KEY_CONTROL = 3; + OPERATOR_SESSION = 4; + } + enum SecurityLevel { + SW_SECURE_CRYPTO = 1; + SW_SECURE_DECODE = 2; + HW_SECURE_CRYPTO = 3; + HW_SECURE_DECODE = 4; + HW_SECURE_ALL = 5; + } + message OutputProtection { + enum CGMS { + COPY_FREE = 0; + COPY_ONCE = 2; + COPY_NEVER = 3; + CGMS_NONE = 0x2A; // PC default! + } + optional ClientIdentification.ClientCapabilities.HdcpVersion Hdcp = 1; // it's most likely a copy of Hdcp version available here, but compiler optimized it away + optional CGMS CgmsFlags = 2; + } + message KeyControl { + required bytes KeyControlBlock = 1; // what is this? + required bytes Iv = 2; + } + message OperatorSessionKeyPermissions { + optional uint32 AllowEncrypt = 1; + optional uint32 AllowDecrypt = 2; + optional uint32 AllowSign = 3; + optional uint32 AllowSignatureVerify = 4; + } + message VideoResolutionConstraint { + optional uint32 MinResolutionPixels = 1; + optional uint32 MaxResolutionPixels = 2; + optional OutputProtection RequiredProtection = 3; + } + optional bytes Id = 1; + optional bytes Iv = 2; + optional bytes Key = 3; + optional KeyType Type = 4; + optional SecurityLevel Level = 5; + optional OutputProtection RequiredProtection = 6; + optional OutputProtection RequestedProtection = 7; + optional KeyControl _KeyControl = 8; // duped names, etc + optional OperatorSessionKeyPermissions _OperatorSessionKeyPermissions = 9; // duped names, etc + repeated VideoResolutionConstraint VideoResolutionConstraints = 10; + } + optional LicenseIdentification Id = 1; + optional Policy _Policy = 2; // duped names, etc + repeated KeyContainer Key = 3; + optional uint32 LicenseStartTime = 4; + optional uint32 RemoteAttestationVerified = 5; // bool? + optional bytes ProviderClientToken = 6; + // there might be more, check with newer versions (I see field 7-8 in a lic) + // this appeared in latest x86: + optional uint32 ProtectionScheme = 7; // type unconfirmed fully, but it's likely as WidevineCencHeader describesit (fourcc) +} + +message LicenseError { + enum Error { + INVALID_DEVICE_CERTIFICATE = 1; + REVOKED_DEVICE_CERTIFICATE = 2; + SERVICE_UNAVAILABLE = 3; + } + //LicenseRequest.RequestType ErrorCode; // clang mismatch + optional Error ErrorCode = 1; +} + +message LicenseRequest { + message ContentIdentification { + message CENC { + //optional bytes Pssh = 1; // the client's definition is opaque, it doesn't care about the contents, but the PSSH has a clear definition that is understood and requested by the server, thus I'll replace it with: + optional WidevineCencHeader Pssh = 1; + optional LicenseType LicenseType = 2; // unfortunately the LicenseType symbols are not present, acceptable value seems to only be 1 (is this persist/don't persist? look into it!) + optional bytes RequestId = 3; + } + message WebM { + optional bytes Header = 1; // identical to CENC, aside from PSSH and the parent field number used + optional LicenseType LicenseType = 2; + optional bytes RequestId = 3; + } + message ExistingLicense { + optional LicenseIdentification LicenseId = 1; + optional uint32 SecondsSinceStarted = 2; + optional uint32 SecondsSinceLastPlayed = 3; + optional bytes SessionUsageTableEntry = 4; // interesting! try to figure out the connection between the usage table blob and KCB! + } + optional CENC CencId = 1; + optional WebM WebmId = 2; + optional ExistingLicense License = 3; + } + enum RequestType { + NEW = 1; + RENEWAL = 2; + RELEASE = 3; + } + optional ClientIdentification ClientId = 1; + optional ContentIdentification ContentId = 2; + optional RequestType Type = 3; + optional uint32 RequestTime = 4; + optional bytes KeyControlNonceDeprecated = 5; + optional ProtocolVersion ProtocolVersion = 6; // lacking symbols for this + optional uint32 KeyControlNonce = 7; + optional EncryptedClientIdentification EncryptedClientId = 8; +} + +// raw pssh hack +message LicenseRequestRaw { + message ContentIdentification { + message CENC { + optional bytes Pssh = 1; // the client's definition is opaque, it doesn't care about the contents, but the PSSH has a clear definition that is understood and requested by the server, thus I'll replace it with: + //optional WidevineCencHeader Pssh = 1; + optional LicenseType LicenseType = 2; // unfortunately the LicenseType symbols are not present, acceptable value seems to only be 1 (is this persist/don't persist? look into it!) + optional bytes RequestId = 3; + } + message WebM { + optional bytes Header = 1; // identical to CENC, aside from PSSH and the parent field number used + optional LicenseType LicenseType = 2; + optional bytes RequestId = 3; + } + message ExistingLicense { + optional LicenseIdentification LicenseId = 1; + optional uint32 SecondsSinceStarted = 2; + optional uint32 SecondsSinceLastPlayed = 3; + optional bytes SessionUsageTableEntry = 4; // interesting! try to figure out the connection between the usage table blob and KCB! + } + optional CENC CencId = 1; + optional WebM WebmId = 2; + optional ExistingLicense License = 3; + } + enum RequestType { + NEW = 1; + RENEWAL = 2; + RELEASE = 3; + } + optional ClientIdentification ClientId = 1; + optional ContentIdentification ContentId = 2; + optional RequestType Type = 3; + optional uint32 RequestTime = 4; + optional bytes KeyControlNonceDeprecated = 5; + optional ProtocolVersion ProtocolVersion = 6; // lacking symbols for this + optional uint32 KeyControlNonce = 7; + optional EncryptedClientIdentification EncryptedClientId = 8; +} + + +message ProvisionedDeviceInfo { + enum WvSecurityLevel { + LEVEL_UNSPECIFIED = 0; + LEVEL_1 = 1; + LEVEL_2 = 2; + LEVEL_3 = 3; + } + optional uint32 SystemId = 1; + optional string Soc = 2; + optional string Manufacturer = 3; + optional string Model = 4; + optional string DeviceType = 5; + optional uint32 ModelYear = 6; + optional WvSecurityLevel SecurityLevel = 7; + optional uint32 TestDevice = 8; // bool? +} + + +// todo: fill +message ProvisioningOptions { +} + +// todo: fill +message ProvisioningRequest { +} + +// todo: fill +message ProvisioningResponse { +} + +message RemoteAttestation { + optional EncryptedClientIdentification Certificate = 1; + optional string Salt = 2; + optional string Signature = 3; +} + +// todo: fill +message SessionInit { +} + +// todo: fill +message SessionState { +} + +// todo: fill +message SignedCertificateStatusList { +} + +message SignedDeviceCertificate { + + //optional bytes DeviceCertificate = 1; // again, they use a buffer where it's supposed to be a message, so we'll replace it with what it really is: + optional DeviceCertificate _DeviceCertificate = 1; // how should we deal with duped names? will have to look at proto docs later + optional bytes Signature = 2; + optional SignedDeviceCertificate Signer = 3; +} + + +// todo: fill +message SignedProvisioningMessage { +} + +// the root of all messages, from either server or client +message SignedMessage { + enum MessageType { + LICENSE_REQUEST = 1; + LICENSE = 2; + ERROR_RESPONSE = 3; + SERVICE_CERTIFICATE_REQUEST = 4; + SERVICE_CERTIFICATE = 5; + } + optional MessageType Type = 1; // has in incorrect overlap with License_KeyContainer_SecurityLevel + optional bytes Msg = 2; // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + optional bytes Signature = 3; // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + optional bytes SessionKey = 4; // often RSA wrapped for licenses + optional RemoteAttestation RemoteAttestation = 5; +} + + + +// This message is copied from google's docs, not reversed: +message WidevineCencHeader { + enum Algorithm { + UNENCRYPTED = 0; + AESCTR = 1; + }; + optional Algorithm algorithm = 1; + repeated bytes key_id = 2; + + // Content provider name. + optional string provider = 3; + + // A content identifier, specified by content provider. + optional bytes content_id = 4; + + // Track type. Acceptable values are SD, HD and AUDIO. Used to + // differentiate content keys used by an asset. + optional string track_type_deprecated = 5; + + // The name of a registered policy to be used for this asset. + optional string policy = 6; + + // Crypto period index, for media using key rotation. + optional uint32 crypto_period_index = 7; + + // Optional protected context for group content. The grouped_license is a + // serialized SignedMessage. + optional bytes grouped_license = 8; + + // Protection scheme identifying the encryption algorithm. + // Represented as one of the following 4CC values: + // 'cenc' (AESCTR), 'cbc1' (AESCBC), + // 'cens' (AESCTR subsample), 'cbcs' (AESCBC subsample). + optional uint32 protection_scheme = 9; + + // Optional. For media using key rotation, this represents the duration + // of each crypto period in seconds. + optional uint32 crypto_period_seconds = 10; +} + + +// remove these when using it outside of protoc: + +// from here on, it's just for testing, these messages don't exist in the binaries, I'm adding them to avoid detecting type programmatically +message SignedLicenseRequest { + enum MessageType { + LICENSE_REQUEST = 1; + LICENSE = 2; + ERROR_RESPONSE = 3; + SERVICE_CERTIFICATE_REQUEST = 4; + SERVICE_CERTIFICATE = 5; + } + optional MessageType Type = 1; // has in incorrect overlap with License_KeyContainer_SecurityLevel + optional LicenseRequest Msg = 2; // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + optional bytes Signature = 3; // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + optional bytes SessionKey = 4; // often RSA wrapped for licenses + optional RemoteAttestation RemoteAttestation = 5; +} + +// hack +message SignedLicenseRequestRaw { + enum MessageType { + LICENSE_REQUEST = 1; + LICENSE = 2; + ERROR_RESPONSE = 3; + SERVICE_CERTIFICATE_REQUEST = 4; + SERVICE_CERTIFICATE = 5; + } + optional MessageType Type = 1; // has in incorrect overlap with License_KeyContainer_SecurityLevel + optional LicenseRequestRaw Msg = 2; // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + optional bytes Signature = 3; // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + optional bytes SessionKey = 4; // often RSA wrapped for licenses + optional RemoteAttestation RemoteAttestation = 5; +} + + +message SignedLicense { + enum MessageType { + LICENSE_REQUEST = 1; + LICENSE = 2; + ERROR_RESPONSE = 3; + SERVICE_CERTIFICATE_REQUEST = 4; + SERVICE_CERTIFICATE = 5; + } + optional MessageType Type = 1; // has in incorrect overlap with License_KeyContainer_SecurityLevel + optional License Msg = 2; // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + optional bytes Signature = 3; // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + optional bytes SessionKey = 4; // often RSA wrapped for licenses + optional RemoteAttestation RemoteAttestation = 5; +} + +message SignedServiceCertificate { + enum MessageType { + LICENSE_REQUEST = 1; + LICENSE = 2; + ERROR_RESPONSE = 3; + SERVICE_CERTIFICATE_REQUEST = 4; + SERVICE_CERTIFICATE = 5; + } + optional MessageType Type = 1; // has in incorrect overlap with License_KeyContainer_SecurityLevel + optional SignedDeviceCertificate Msg = 2; // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + optional bytes Signature = 3; // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + optional bytes SessionKey = 4; // often RSA wrapped for licenses + optional RemoteAttestation RemoteAttestation = 5; +} + +//vmp support +message FileHashes { + message Signature { + optional string filename = 1; + optional bool test_signing = 2; //0 - release, 1 - testing + optional bytes SHA512Hash = 3; + optional bool main_exe = 4; //0 for dlls, 1 for exe, this is field 3 in file + optional bytes signature = 5; + } + optional bytes signer = 1; + repeated Signature signatures = 2; +} diff --git a/widevine/cdm.go b/widevine/cdm.go new file mode 100644 index 0000000..b084ef3 --- /dev/null +++ b/widevine/cdm.go @@ -0,0 +1,269 @@ +package widevine + +import ( + "bytes" + "crypto" + "crypto/aes" + "crypto/cipher" + "crypto/rsa" + "crypto/sha1" + "crypto/x509" + "encoding/pem" + "errors" + "github.com/aead/cmac" + "google.golang.org/protobuf/proto" + "lukechampine.com/frand" + "math" + "time" +) + +type CDM struct { + privateKey *rsa.PrivateKey + clientID []byte + sessionID [32]byte + + widevineCencHeader WidevineCencHeader + signedDeviceCertificate SignedDeviceCertificate + privacyMode bool +} + +type Key struct { + ID []byte + Type License_KeyContainer_KeyType + Value []byte +} + +// Creates a new CDM object with the specified device information. +func NewCDM(privateKey string, clientID []byte, initData []byte) (CDM, error) { + block, _ := pem.Decode([]byte(privateKey)) + if block == nil || block.Type != "RSA PRIVATE KEY" { + return CDM{}, errors.New("failed to decode device private key") + } + keyParsed, err := x509.ParsePKCS1PrivateKey(block.Bytes) + if err != nil { + return CDM{}, err + } + + var widevineCencHeader WidevineCencHeader + if len(initData) < 32 { + return CDM{}, errors.New("initData not long enough") + } + if err := proto.Unmarshal(initData[32:], &widevineCencHeader); err != nil { + return CDM{}, err + } + + sessionID := func() (s [32]byte) { + c := []byte("ABCDEF0123456789") + for i := 0; i < 16; i++ { + s[i] = c[frand.Intn(len(c))] + } + s[16] = '0' + s[17] = '1' + for i := 18; i < 32; i++ { + s[i] = '0' + } + return s + }() + + return CDM{ + privateKey: keyParsed, + clientID: clientID, + + widevineCencHeader: widevineCencHeader, + + sessionID: sessionID, + }, nil +} + +// Creates a new CDM object using the default device configuration. +func NewDefaultCDM(initData []byte) (CDM, error) { + return NewCDM(DefaultPrivateKey, DefaultClientID, initData) +} + +// Sets a device certificate. This is makes generating the license request +// more complicated but is supported. This is usually not necessary for most +// Widevine applications. +func (c *CDM) SetServiceCertificate(certData []byte) error { + var message SignedMessage + if err := proto.Unmarshal(certData, &message); err != nil { + return err + } + if err := proto.Unmarshal(message.Msg, &c.signedDeviceCertificate); err != nil { + return err + } + c.privacyMode = true + return nil +} + +// Generates the license request data. This is sent to the license server via +// HTTP POST and the server in turn returns the license response. +func (c *CDM) GetLicenseRequest() ([]byte, error) { + var licenseRequest SignedLicenseRequest + licenseRequest.Msg = new(LicenseRequest) + licenseRequest.Msg.ContentId = new(LicenseRequest_ContentIdentification) + licenseRequest.Msg.ContentId.CencId = new(LicenseRequest_ContentIdentification_CENC) + + // this is probably really bad for the GC but protobuf uses pointers for optional + // fields so it is necessary and this is not a long running program + { + v := SignedLicenseRequest_LICENSE_REQUEST + licenseRequest.Type = &v + } + + licenseRequest.Msg.ContentId.CencId.Pssh = &c.widevineCencHeader + + { + v := LicenseType_DEFAULT + licenseRequest.Msg.ContentId.CencId.LicenseType = &v + } + + licenseRequest.Msg.ContentId.CencId.RequestId = c.sessionID[:] + + { + v := LicenseRequest_NEW + licenseRequest.Msg.Type = &v + } + + { + v := uint32(time.Now().Unix()) + licenseRequest.Msg.RequestTime = &v + } + + { + v := ProtocolVersion_CURRENT + licenseRequest.Msg.ProtocolVersion = &v + } + + { + v := uint32(frand.Uint64n(math.MaxUint32)) + licenseRequest.Msg.KeyControlNonce = &v + } + + if c.privacyMode { + pad := func(data []byte, blockSize int) []byte { + padlen := blockSize - (len(data) % blockSize) + if padlen == 0 { + padlen = blockSize + } + return append(data, bytes.Repeat([]byte{byte(padlen)}, padlen)...) + } + const blockSize = 16 + + var cidKey, cidIV [blockSize]byte + frand.Read(cidKey[:]) + frand.Read(cidIV[:]) + + block, err := aes.NewCipher(cidKey[:]) + if err != nil { + return nil, err + } + + paddedClientID := pad(c.clientID, blockSize) + encryptedClientID := make([]byte, len(paddedClientID)) + cipher.NewCBCEncrypter(block, cidIV[:]).CryptBlocks(encryptedClientID, paddedClientID) + + servicePublicKey, err := x509.ParsePKCS1PublicKey(c.signedDeviceCertificate.XDeviceCertificate.PublicKey) + if err != nil { + return nil, err + } + + encryptedCIDKey, err := rsa.EncryptOAEP(sha1.New(), frand.Reader, servicePublicKey, cidKey[:], nil) + if err != nil { + return nil, err + } + + licenseRequest.Msg.EncryptedClientId = new(EncryptedClientIdentification) + { + v := string(c.signedDeviceCertificate.XDeviceCertificate.ServiceId) + licenseRequest.Msg.EncryptedClientId.ServiceId = &v + } + licenseRequest.Msg.EncryptedClientId.ServiceCertificateSerialNumber = c.signedDeviceCertificate.XDeviceCertificate.SerialNumber + licenseRequest.Msg.EncryptedClientId.EncryptedClientId = encryptedClientID + licenseRequest.Msg.EncryptedClientId.EncryptedClientIdIv = cidIV[:] + licenseRequest.Msg.EncryptedClientId.EncryptedPrivacyKey = encryptedCIDKey + } else { + licenseRequest.Msg.ClientId = new(ClientIdentification) + if err := proto.Unmarshal(c.clientID, licenseRequest.Msg.ClientId); err != nil { + return nil, err + } + } + + { + data, err := proto.Marshal(licenseRequest.Msg) + if err != nil { + return nil, err + } + hash := sha1.Sum(data) + if licenseRequest.Signature, err = rsa.SignPSS(frand.Reader, c.privateKey, crypto.SHA1, hash[:], &rsa.PSSOptions{SaltLength: rsa.PSSSaltLengthEqualsHash}); err != nil { + return nil, err + } + } + + return proto.Marshal(&licenseRequest) +} + +// Retrieves the keys from the license response data. These keys can be +// used to decrypt the DASH-MP4. +func (c *CDM) GetLicenseKeys(licenseRequest []byte, licenseResponse []byte) (keys []Key, err error) { + var license SignedLicense + if err = proto.Unmarshal(licenseResponse, &license); err != nil { + return + } + + var licenseRequestParsed SignedLicenseRequest + if err = proto.Unmarshal(licenseRequest, &licenseRequestParsed); err != nil { + return + } + licenseRequestMsg, err := proto.Marshal(licenseRequestParsed.Msg) + if err != nil { + return + } + + sessionKey, err := rsa.DecryptOAEP(sha1.New(), frand.Reader, c.privateKey, license.SessionKey, nil) + if err != nil { + return + } + + sessionKeyBlock, err := aes.NewCipher(sessionKey) + if err != nil { + return + } + + encryptionKey := []byte{1, 'E', 'N', 'C', 'R', 'Y', 'P', 'T', 'I', 'O', 'N', 0} + encryptionKey = append(encryptionKey, licenseRequestMsg...) + encryptionKey = append(encryptionKey, []byte{0, 0, 0, 0x80}...) + encryptionKeyCmac, err := cmac.Sum(encryptionKey, sessionKeyBlock, sessionKeyBlock.BlockSize()) + if err != nil { + return + } + encryptionKeyCipher, err := aes.NewCipher(encryptionKeyCmac) + if err != nil { + return + } + + unpad := func(b []byte) []byte { + if len(b) == 0 { + return b + } + // pks padding is designed so that the value of all the padding bytes is + // the number of padding bytes repeated so to figure out how many + // padding bytes there are we can just look at the value of the last + // byte + // i.e if there are 6 padding bytes then it will look at like + // 0x6 0x6 0x6 0x6 0x6 0x6 + count := int(b[len(b)-1]) + return b[0 : len(b)-count] + } + for _, key := range license.Msg.Key { + decrypter := cipher.NewCBCDecrypter(encryptionKeyCipher, key.Iv) + decryptedKey := make([]byte, len(key.Key)) + decrypter.CryptBlocks(decryptedKey, key.Key) + keys = append(keys, Key{ + ID: key.Id, + Type: *key.Type, + Value: unpad(decryptedKey), + }) + } + + return +} diff --git a/widevine/consts.go b/widevine/consts.go new file mode 100644 index 0000000..d698f17 --- /dev/null +++ b/widevine/consts.go @@ -0,0 +1,38 @@ +package widevine + +// Keys from Android SDK built for x86 +// I found these via Github search. I lack the expertise involved in +// extracting them. From what I understand, it usually involves TrustZone +// exploits or whatever the analogous system for the device is. + +const DefaultPrivateKey = ` +-----BEGIN RSA PRIVATE KEY----- +MIIEpQIBAAKCAQEA4sUKDpvMG/idF8oCH5AVSwFd5Mk+rEwOBsLZMYdliXWe1hn9 +mdE6u9pjsr+bLrZjlKxMFqPPxbIUcC1Ii7BFSje2Fd8kxnaIprQWxDPgK+NSSx7v +Un452TyB1L9lx39ZBt0PlRfwjkCodX+I9y+oBga73NRh7hPbtLzXe/r/ubFBaEu+ +aRkDZBwYPqHgH1RoFLuyFNMjfqGcPosGxceDtvPysmBxB93Hk2evml5fjdYGg6tx +z510g+XFPDFv7GSy1KuWqit83MqzPls9qAQMkwUc05ggjDhGCKW4/p97fn23WDFE +3TzSSsQvyJLKA3s9oJbtJCD/gOHYqDvnWn8zPwIDAQABAoIBAQDCWe1Mp+o+7sx0 +XwWC15HoPruiIXg9YtGCqexLrqcvMEd5Z70Z32BfL8TSpbTyTA78lM6BeNPRs9Yg +bi8GyYQZH7ZG+IAkN+LWPPJmJa+y7ZjSGSkzoksiC+GZ3I/2cwZyA3Qfa+0XfgLi +8PMKJyXyREMt+DgWO57JQC/OakhRdCR19mM6NKd+ynd/IEz/NIbjMLDVKwW8HEPx +N3r5CU9O96nr62DI68KVj3jwUR3cDi/5xfhosYhCQjHJuobNbeFR18dY2nQNLWYd +S0wtskla1fl9eYHwYAzwru4wHT4WJC7+V4pscfCI0YZB6PslxDKrv73l5H1tz4cf +Vy58NRSBAoGBAPSmjoVtQzTvQ6PZIs81SF1ulJI9kUpyFaBoSSgt+2ZkeNtF6Hih +Zm7OVJ9wg9sfjpB3SFBUjuhXz/ts/t6dkA2PgCbrvhBMRKSGbfyhhtM2gRf002I4 +bJ7Y0C/ont4WzC/XbXEkAmh+fG2/JRvbdVQaIdyS6MmVHtCtRsHEQZS5AoGBAO1K +IXOKAFA+320+Hkbqskfevmxrv+JHIdetliaREZwQH+VYUUM8u5/Kt3oyMat+mH90 +rZOKQK2zM8cz4tKclTUT54nrtICxeo6UHVc56FqXZ6sVvVgm8Cnvt1md4XwG4FwQ +r/OlaM6Hr5HRf8dkzuzqm4ZQYRHGzZ6AMphj8Xu3AoGAdmo7p5dIJVH98kuCDrsi +iJ6iaNpF/buUfiyb5EfFXD0bRj7jE6hDdTSHPxjtqVzv2zrxFHipJwqBz5dlEYlA +FWA0ziHiv+66dsveZp4kLQ0/lMHaorre0E/vDJFSe/qa4DksbsvYIo2+WjxfkMk7 +U/bGFwZAiHmWDbkg+16rw3kCgYEAyyodWf9eJVavlakJ404vNrnP8KSQtfyRTUii +toKewTBNHuBvM1JckoPOdCFlxZ+ukfIka56DojU8r+IM4qaOWdOg+sWE1mses9S9 +CmHaPzZC3IjQhRlRp5ZHNcOnu7lnf2wKOmH1Sl+CQydMcDwvr0lvv6AyfDXq9zps +F2365CECgYEAmYgs/qwnh9m0aGDw/ZGrASoE0TxlpizPvsVDGx9t9UGC2Z+5QvAE +ZcQeKoLCbktr0BnRLI+W1g+KpXQGcnSF9VX/qwUlf72XA6C6kobQvW+Yd/H/IN5d +jPqoL/m41rRzm+J+9/Tfc8Aiy1kkllUYnVJdC5QLAIswuhI8lkaFTN4= +-----END RSA PRIVATE KEY----- +` + +var DefaultClientID = []byte{8, 1, 18, 237, 9, 10, 176, 2, 8, 2, 18, 16, 247, 149, 61, 229, 178, 130, 18, 227, 78, 162, 65, 84, 240, 234, 99, 108, 24, 233, 237, 172, 245, 5, 34, 142, 2, 48, 130, 1, 10, 2, 130, 1, 1, 0, 226, 197, 10, 14, 155, 204, 27, 248, 157, 23, 202, 2, 31, 144, 21, 75, 1, 93, 228, 201, 62, 172, 76, 14, 6, 194, 217, 49, 135, 101, 137, 117, 158, 214, 25, 253, 153, 209, 58, 187, 218, 99, 178, 191, 155, 46, 182, 99, 148, 172, 76, 22, 163, 207, 197, 178, 20, 112, 45, 72, 139, 176, 69, 74, 55, 182, 21, 223, 36, 198, 118, 136, 166, 180, 22, 196, 51, 224, 43, 227, 82, 75, 30, 239, 82, 126, 57, 217, 60, 129, 212, 191, 101, 199, 127, 89, 6, 221, 15, 149, 23, 240, 142, 64, 168, 117, 127, 136, 247, 47, 168, 6, 6, 187, 220, 212, 97, 238, 19, 219, 180, 188, 215, 123, 250, 255, 185, 177, 65, 104, 75, 190, 105, 25, 3, 100, 28, 24, 62, 161, 224, 31, 84, 104, 20, 187, 178, 20, 211, 35, 126, 161, 156, 62, 139, 6, 197, 199, 131, 182, 243, 242, 178, 96, 113, 7, 221, 199, 147, 103, 175, 154, 94, 95, 141, 214, 6, 131, 171, 113, 207, 157, 116, 131, 229, 197, 60, 49, 111, 236, 100, 178, 212, 171, 150, 170, 43, 124, 220, 202, 179, 62, 91, 61, 168, 4, 12, 147, 5, 28, 211, 152, 32, 140, 56, 70, 8, 165, 184, 254, 159, 123, 126, 125, 183, 88, 49, 68, 221, 60, 210, 74, 196, 47, 200, 146, 202, 3, 123, 61, 160, 150, 237, 36, 32, 255, 128, 225, 216, 168, 59, 231, 90, 127, 51, 63, 2, 3, 1, 0, 1, 40, 240, 34, 72, 1, 18, 128, 2, 181, 69, 135, 13, 36, 72, 2, 2, 176, 112, 152, 226, 24, 117, 128, 238, 225, 194, 114, 8, 188, 180, 141, 162, 26, 161, 183, 202, 49, 147, 218, 1, 14, 207, 11, 125, 231, 24, 127, 10, 115, 147, 50, 61, 106, 13, 38, 240, 103, 0, 123, 75, 241, 234, 38, 11, 231, 115, 202, 98, 108, 161, 63, 250, 36, 2, 164, 18, 176, 208, 79, 130, 11, 48, 125, 118, 127, 0, 60, 69, 146, 90, 115, 83, 94, 6, 75, 201, 83, 24, 13, 146, 193, 185, 192, 51, 90, 159, 92, 100, 180, 221, 0, 52, 238, 87, 118, 248, 118, 12, 10, 17, 215, 221, 187, 51, 97, 88, 129, 20, 101, 222, 109, 13, 143, 175, 231, 182, 40, 244, 155, 184, 103, 136, 83, 218, 66, 71, 52, 241, 23, 51, 254, 103, 70, 28, 40, 194, 255, 121, 80, 157, 82, 23, 39, 124, 215, 136, 124, 201, 225, 190, 206, 164, 226, 20, 7, 221, 83, 94, 218, 57, 9, 117, 238, 140, 109, 81, 13, 156, 77, 13, 48, 165, 153, 72, 179, 42, 38, 61, 146, 233, 203, 159, 27, 38, 41, 64, 88, 241, 240, 177, 17, 87, 14, 73, 104, 117, 126, 82, 184, 192, 44, 104, 112, 234, 153, 199, 154, 57, 53, 150, 187, 248, 44, 48, 130, 220, 36, 177, 193, 152, 136, 71, 86, 95, 131, 253, 140, 9, 124, 36, 219, 137, 187, 228, 115, 46, 20, 197, 102, 29, 6, 89, 242, 34, 26, 180, 5, 10, 174, 2, 8, 1, 18, 16, 105, 227, 232, 152, 187, 44, 63, 184, 163, 179, 40, 29, 132, 248, 140, 20, 24, 142, 213, 190, 145, 5, 34, 142, 2, 48, 130, 1, 10, 2, 130, 1, 1, 0, 216, 246, 233, 181, 137, 240, 81, 32, 233, 164, 62, 208, 217, 78, 161, 254, 9, 149, 1, 109, 189, 30, 43, 64, 167, 220, 209, 197, 127, 195, 5, 80, 60, 207, 19, 63, 158, 152, 175, 206, 78, 230, 255, 132, 220, 66, 36, 38, 168, 255, 250, 79, 228, 191, 45, 68, 213, 15, 20, 58, 235, 188, 32, 76, 163, 180, 103, 250, 37, 27, 250, 96, 63, 219, 37, 226, 39, 168, 175, 169, 195, 125, 10, 239, 98, 230, 163, 148, 215, 40, 40, 159, 212, 150, 101, 27, 46, 140, 81, 65, 242, 124, 85, 173, 230, 57, 47, 55, 170, 211, 111, 55, 206, 125, 66, 131, 91, 45, 113, 126, 45, 56, 116, 251, 186, 211, 243, 20, 111, 209, 120, 49, 80, 183, 67, 191, 24, 185, 115, 87, 0, 116, 119, 91, 39, 221, 34, 140, 59, 133, 203, 142, 22, 93, 157, 202, 237, 23, 216, 229, 142, 152, 59, 198, 51, 8, 150, 117, 137, 82, 172, 67, 163, 180, 208, 145, 60, 173, 38, 101, 37, 210, 71, 12, 237, 185, 221, 4, 183, 171, 1, 210, 69, 25, 165, 220, 234, 132, 152, 225, 227, 114, 252, 129, 131, 150, 226, 194, 65, 29, 202, 100, 68, 44, 203, 249, 139, 121, 93, 96, 129, 14, 56, 48, 90, 251, 92, 227, 62, 173, 223, 184, 255, 125, 120, 171, 247, 94, 65, 184, 199, 170, 53, 133, 185, 90, 252, 136, 134, 138, 110, 175, 145, 235, 116, 161, 2, 3, 1, 0, 1, 40, 240, 34, 18, 128, 3, 34, 139, 99, 48, 235, 63, 144, 179, 86, 239, 191, 17, 146, 182, 39, 189, 182, 151, 32, 160, 237, 174, 2, 222, 89, 190, 253, 2, 13, 123, 235, 22, 92, 39, 73, 186, 62, 169, 30, 245, 70, 237, 136, 149, 149, 149, 73, 179, 121, 93, 132, 136, 15, 7, 48, 7, 49, 227, 99, 202, 205, 175, 119, 224, 177, 123, 82, 38, 220, 184, 219, 151, 99, 53, 11, 69, 231, 226, 118, 142, 176, 33, 127, 116, 54, 155, 177, 8, 229, 170, 33, 100, 106, 67, 216, 77, 28, 175, 231, 85, 143, 218, 60, 199, 75, 137, 71, 99, 86, 71, 193, 85, 161, 84, 18, 93, 154, 90, 119, 115, 63, 225, 12, 193, 44, 219, 104, 254, 220, 254, 80, 172, 153, 193, 174, 210, 115, 247, 147, 65, 205, 190, 101, 192, 210, 221, 145, 14, 222, 81, 145, 176, 127, 58, 224, 167, 255, 112, 65, 175, 37, 16, 65, 169, 202, 73, 92, 167, 198, 248, 139, 106, 17, 109, 64, 0, 250, 109, 142, 232, 32, 206, 102, 68, 205, 26, 185, 197, 49, 159, 234, 138, 254, 109, 122, 202, 140, 42, 65, 75, 209, 181, 72, 236, 175, 8, 209, 117, 147, 156, 250, 148, 111, 10, 177, 120, 96, 67, 18, 250, 0, 49, 204, 162, 233, 113, 189, 66, 34, 135, 35, 216, 228, 202, 98, 153, 213, 223, 81, 209, 16, 228, 112, 54, 18, 163, 98, 53, 83, 72, 59, 138, 143, 211, 78, 227, 91, 157, 114, 1, 228, 225, 58, 188, 184, 39, 109, 177, 179, 196, 93, 144, 128, 165, 56, 96, 26, 184, 178, 37, 210, 82, 192, 225, 249, 76, 205, 111, 149, 125, 9, 121, 197, 140, 79, 208, 78, 109, 186, 25, 244, 135, 239, 56, 224, 59, 37, 83, 198, 69, 237, 77, 93, 83, 100, 41, 172, 128, 41, 125, 245, 195, 247, 8, 0, 0, 41, 54, 233, 24, 32, 203, 199, 189, 235, 63, 34, 243, 175, 254, 97, 140, 153, 66, 71, 61, 132, 135, 66, 0, 68, 107, 128, 70, 2, 17, 176, 114, 204, 227, 107, 117, 16, 236, 212, 202, 210, 253, 200, 117, 154, 133, 121, 164, 155, 250, 220, 18, 10, 189, 1, 198, 188, 185, 26, 22, 10, 12, 99, 111, 109, 112, 97, 110, 121, 95, 110, 97, 109, 101, 18, 6, 71, 111, 111, 103, 108, 101, 26, 39, 10, 10, 109, 111, 100, 101, 108, 95, 110, 97, 109, 101, 18, 25, 65, 110, 100, 114, 111, 105, 100, 32, 83, 68, 75, 32, 98, 117, 105, 108, 116, 32, 102, 111, 114, 32, 120, 56, 54, 26, 24, 10, 17, 97, 114, 99, 104, 105, 116, 101, 99, 116, 117, 114, 101, 95, 110, 97, 109, 101, 18, 3, 120, 56, 54, 26, 26, 10, 11, 100, 101, 118, 105, 99, 101, 95, 110, 97, 109, 101, 18, 11, 103, 101, 110, 101, 114, 105, 99, 95, 120, 56, 54, 26, 36, 10, 12, 112, 114, 111, 100, 117, 99, 116, 95, 110, 97, 109, 101, 18, 20, 115, 100, 107, 95, 103, 111, 111, 103, 108, 101, 95, 112, 104, 111, 110, 101, 95, 120, 56, 54, 26, 91, 10, 10, 98, 117, 105, 108, 100, 95, 105, 110, 102, 111, 18, 77, 103, 111, 111, 103, 108, 101, 47, 115, 100, 107, 95, 103, 111, 111, 103, 108, 101, 95, 112, 104, 111, 110, 101, 95, 120, 56, 54, 47, 103, 101, 110, 101, 114, 105, 99, 95, 120, 56, 54, 58, 55, 46, 49, 46, 49, 47, 78, 89, 67, 47, 53, 52, 54, 52, 56, 57, 55, 58, 117, 115, 101, 114, 100, 101, 98, 117, 103, 47, 116, 101, 115, 116, 45, 107, 101, 121, 115, 26, 45, 10, 9, 100, 101, 118, 105, 99, 101, 95, 105, 100, 18, 32, 122, 100, 102, 68, 67, 80, 72, 97, 72, 114, 66, 81, 97, 107, 113, 75, 104, 69, 99, 70, 113, 88, 105, 76, 119, 98, 98, 108, 74, 119, 103, 0, 26, 38, 10, 20, 119, 105, 100, 101, 118, 105, 110, 101, 95, 99, 100, 109, 95, 118, 101, 114, 115, 105, 111, 110, 18, 14, 118, 52, 46, 49, 46, 48, 45, 97, 110, 100, 114, 111, 105, 100, 26, 36, 10, 31, 111, 101, 109, 95, 99, 114, 121, 112, 116, 111, 95, 115, 101, 99, 117, 114, 105, 116, 121, 95, 112, 97, 116, 99, 104, 95, 108, 101, 118, 101, 108, 18, 1, 48, 50, 8, 16, 1, 32, 0, 40, 11, 48, 0} diff --git a/widevine/pssh.go b/widevine/pssh.go new file mode 100644 index 0000000..1789761 --- /dev/null +++ b/widevine/pssh.go @@ -0,0 +1,115 @@ +package widevine + +import ( + "bytes" + "encoding/base64" + "encoding/xml" + "errors" + "io" + "net/http" +) + +// This function retrieves the PSSH/Init Data from a given MPD file reader. +// Example file: https://bitmovin-a.akamaihd.net/content/art-of-motion_drm/mpds/11331.mpd +func InitDataFromMPD(r io.Reader) ([]byte, error) { + type mpd struct { + XMLName xml.Name `xml:"MPD"` + Text string `xml:",chardata"` + ID string `xml:"id,attr"` + Profiles string `xml:"profiles,attr"` + Type string `xml:"type,attr"` + AvailabilityStartTime string `xml:"availabilityStartTime,attr"` + PublishTime string `xml:"publishTime,attr"` + MediaPresentationDuration string `xml:"mediaPresentationDuration,attr"` + MinBufferTime string `xml:"minBufferTime,attr"` + Version string `xml:"version,attr"` + Ns2 string `xml:"ns2,attr"` + Xmlns string `xml:"xmlns,attr"` + Bitmovin string `xml:"bitmovin,attr"` + Period struct { + Text string `xml:",chardata"` + AdaptationSet []struct { + Text string `xml:",chardata"` + MimeType string `xml:"mimeType,attr"` + Codecs string `xml:"codecs,attr"` + Lang string `xml:"lang,attr"` + Label string `xml:"label,attr"` + SegmentTemplate struct { + Text string `xml:",chardata"` + Media string `xml:"media,attr"` + Initialization string `xml:"initialization,attr"` + Duration string `xml:"duration,attr"` + StartNumber string `xml:"startNumber,attr"` + Timescale string `xml:"timescale,attr"` + } `xml:"SegmentTemplate"` + ContentProtection []struct { + Text string `xml:",chardata"` + SchemeIdUri string `xml:"schemeIdUri,attr"` + Value string `xml:"value,attr"` + DefaultKID string `xml:"default_KID,attr"` + Pssh string `xml:"pssh"` + } `xml:"ContentProtection"` + Representation []struct { + Text string `xml:",chardata"` + ID string `xml:"id,attr"` + Bandwidth string `xml:"bandwidth,attr"` + Width string `xml:"width,attr"` + Height string `xml:"height,attr"` + FrameRate string `xml:"frameRate,attr"` + AudioSamplingRate string `xml:"audioSamplingRate,attr"` + ContentProtection []struct { + Text string `xml:",chardata"` + SchemeIdUri string `xml:"schemeIdUri,attr"` + Value string `xml:"value,attr"` + DefaultKID string `xml:"default_KID,attr"` + Cenc string `xml:"cenc,attr"` + Pssh struct { + Text string `xml:",chardata"` + Cenc string `xml:"cenc,attr"` + } `xml:"pssh"` + } `xml:"ContentProtection"` + } `xml:"Representation"` + AudioChannelConfiguration struct { + Text string `xml:",chardata"` + SchemeIdUri string `xml:"schemeIdUri,attr"` + Value string `xml:"value,attr"` + } `xml:"AudioChannelConfiguration"` + } `xml:"AdaptationSet"` + } `xml:"Period"` + } + + var mpdPlaylist mpd + if err := xml.NewDecoder(r).Decode(&mpdPlaylist); err != nil { + return nil, err + } + + const widevineSchemeIdURI = "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed" + for _, adaptionSet := range mpdPlaylist.Period.AdaptationSet { + for _, protection := range adaptionSet.ContentProtection { + if protection.SchemeIdUri == widevineSchemeIdURI && len(protection.Pssh) > 0 { + return base64.StdEncoding.DecodeString(protection.Pssh) + } + } + } + for _, adaptionSet := range mpdPlaylist.Period.AdaptationSet { + for _, representation := range adaptionSet.Representation { + for _, protection := range representation.ContentProtection { + if protection.SchemeIdUri == widevineSchemeIdURI && len(protection.Pssh.Text) > 0 { + return base64.StdEncoding.DecodeString(protection.Pssh.Text) + } + } + } + } + + return nil, errors.New("no init data found") +} + +// This function retrieves certificate data from a given license server. +func GetCertData(client *http.Client, licenseURL string) ([]byte, error) { + response, err := client.Post(licenseURL, "application/x-www-form-urlencoded", bytes.NewReader([]byte{0x08, 0x04})) + if err != nil { + return nil, err + } + defer response.Body.Close() + return io.ReadAll(response.Body) +} diff --git a/widevine/wv_proto2.pb.go b/widevine/wv_proto2.pb.go new file mode 100644 index 0000000..ccaccfa --- /dev/null +++ b/widevine/wv_proto2.pb.go @@ -0,0 +1,5729 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.25.0-devel +// protoc v3.12.4 +// source: wv_proto2.proto + +package widevine + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// todo: fill (for this top-level type, it might be impossible/difficult) +type LicenseType int32 + +const ( + LicenseType_ZERO LicenseType = 0 + LicenseType_DEFAULT LicenseType = 1 // 1 is STREAMING/temporary license; on recent versions may go up to 3 (latest x86); it might be persist/don't persist type, unconfirmed + LicenseType_OFFLINE LicenseType = 2 +) + +// Enum value maps for LicenseType. +var ( + LicenseType_name = map[int32]string{ + 0: "ZERO", + 1: "DEFAULT", + 2: "OFFLINE", + } + LicenseType_value = map[string]int32{ + "ZERO": 0, + "DEFAULT": 1, + "OFFLINE": 2, + } +) + +func (x LicenseType) Enum() *LicenseType { + p := new(LicenseType) + *p = x + return p +} + +func (x LicenseType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (LicenseType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[0].Descriptor() +} + +func (LicenseType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[0] +} + +func (x LicenseType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *LicenseType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = LicenseType(num) + return nil +} + +// Deprecated: Use LicenseType.Descriptor instead. +func (LicenseType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{0} +} + +// todo: fill (for this top-level type, it might be impossible/difficult) +// this is just a guess because these globals got lost, but really, do we need more? +type ProtocolVersion int32 + +const ( + ProtocolVersion_CURRENT ProtocolVersion = 21 // don't have symbols for this +) + +// Enum value maps for ProtocolVersion. +var ( + ProtocolVersion_name = map[int32]string{ + 21: "CURRENT", + } + ProtocolVersion_value = map[string]int32{ + "CURRENT": 21, + } +) + +func (x ProtocolVersion) Enum() *ProtocolVersion { + p := new(ProtocolVersion) + *p = x + return p +} + +func (x ProtocolVersion) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ProtocolVersion) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[1].Descriptor() +} + +func (ProtocolVersion) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[1] +} + +func (x ProtocolVersion) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *ProtocolVersion) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = ProtocolVersion(num) + return nil +} + +// Deprecated: Use ProtocolVersion.Descriptor instead. +func (ProtocolVersion) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{1} +} + +type ClientIdentification_TokenType int32 + +const ( + ClientIdentification_KEYBOX ClientIdentification_TokenType = 0 + ClientIdentification_DEVICE_CERTIFICATE ClientIdentification_TokenType = 1 + ClientIdentification_REMOTE_ATTESTATION_CERTIFICATE ClientIdentification_TokenType = 2 +) + +// Enum value maps for ClientIdentification_TokenType. +var ( + ClientIdentification_TokenType_name = map[int32]string{ + 0: "KEYBOX", + 1: "DEVICE_CERTIFICATE", + 2: "REMOTE_ATTESTATION_CERTIFICATE", + } + ClientIdentification_TokenType_value = map[string]int32{ + "KEYBOX": 0, + "DEVICE_CERTIFICATE": 1, + "REMOTE_ATTESTATION_CERTIFICATE": 2, + } +) + +func (x ClientIdentification_TokenType) Enum() *ClientIdentification_TokenType { + p := new(ClientIdentification_TokenType) + *p = x + return p +} + +func (x ClientIdentification_TokenType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ClientIdentification_TokenType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[2].Descriptor() +} + +func (ClientIdentification_TokenType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[2] +} + +func (x ClientIdentification_TokenType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *ClientIdentification_TokenType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = ClientIdentification_TokenType(num) + return nil +} + +// Deprecated: Use ClientIdentification_TokenType.Descriptor instead. +func (ClientIdentification_TokenType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{0, 0} +} + +type ClientIdentification_ClientCapabilities_HdcpVersion int32 + +const ( + ClientIdentification_ClientCapabilities_HDCP_NONE ClientIdentification_ClientCapabilities_HdcpVersion = 0 + ClientIdentification_ClientCapabilities_HDCP_V1 ClientIdentification_ClientCapabilities_HdcpVersion = 1 + ClientIdentification_ClientCapabilities_HDCP_V2 ClientIdentification_ClientCapabilities_HdcpVersion = 2 + ClientIdentification_ClientCapabilities_HDCP_V2_1 ClientIdentification_ClientCapabilities_HdcpVersion = 3 + ClientIdentification_ClientCapabilities_HDCP_V2_2 ClientIdentification_ClientCapabilities_HdcpVersion = 4 +) + +// Enum value maps for ClientIdentification_ClientCapabilities_HdcpVersion. +var ( + ClientIdentification_ClientCapabilities_HdcpVersion_name = map[int32]string{ + 0: "HDCP_NONE", + 1: "HDCP_V1", + 2: "HDCP_V2", + 3: "HDCP_V2_1", + 4: "HDCP_V2_2", + } + ClientIdentification_ClientCapabilities_HdcpVersion_value = map[string]int32{ + "HDCP_NONE": 0, + "HDCP_V1": 1, + "HDCP_V2": 2, + "HDCP_V2_1": 3, + "HDCP_V2_2": 4, + } +) + +func (x ClientIdentification_ClientCapabilities_HdcpVersion) Enum() *ClientIdentification_ClientCapabilities_HdcpVersion { + p := new(ClientIdentification_ClientCapabilities_HdcpVersion) + *p = x + return p +} + +func (x ClientIdentification_ClientCapabilities_HdcpVersion) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ClientIdentification_ClientCapabilities_HdcpVersion) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[3].Descriptor() +} + +func (ClientIdentification_ClientCapabilities_HdcpVersion) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[3] +} + +func (x ClientIdentification_ClientCapabilities_HdcpVersion) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *ClientIdentification_ClientCapabilities_HdcpVersion) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = ClientIdentification_ClientCapabilities_HdcpVersion(num) + return nil +} + +// Deprecated: Use ClientIdentification_ClientCapabilities_HdcpVersion.Descriptor instead. +func (ClientIdentification_ClientCapabilities_HdcpVersion) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{0, 1, 0} +} + +type DeviceCertificate_CertificateType int32 + +const ( + DeviceCertificate_ROOT DeviceCertificate_CertificateType = 0 + DeviceCertificate_INTERMEDIATE DeviceCertificate_CertificateType = 1 + DeviceCertificate_USER_DEVICE DeviceCertificate_CertificateType = 2 + DeviceCertificate_SERVICE DeviceCertificate_CertificateType = 3 +) + +// Enum value maps for DeviceCertificate_CertificateType. +var ( + DeviceCertificate_CertificateType_name = map[int32]string{ + 0: "ROOT", + 1: "INTERMEDIATE", + 2: "USER_DEVICE", + 3: "SERVICE", + } + DeviceCertificate_CertificateType_value = map[string]int32{ + "ROOT": 0, + "INTERMEDIATE": 1, + "USER_DEVICE": 2, + "SERVICE": 3, + } +) + +func (x DeviceCertificate_CertificateType) Enum() *DeviceCertificate_CertificateType { + p := new(DeviceCertificate_CertificateType) + *p = x + return p +} + +func (x DeviceCertificate_CertificateType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (DeviceCertificate_CertificateType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[4].Descriptor() +} + +func (DeviceCertificate_CertificateType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[4] +} + +func (x DeviceCertificate_CertificateType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *DeviceCertificate_CertificateType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = DeviceCertificate_CertificateType(num) + return nil +} + +// Deprecated: Use DeviceCertificate_CertificateType.Descriptor instead. +func (DeviceCertificate_CertificateType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{1, 0} +} + +type DeviceCertificateStatus_CertificateStatus int32 + +const ( + DeviceCertificateStatus_VALID DeviceCertificateStatus_CertificateStatus = 0 + DeviceCertificateStatus_REVOKED DeviceCertificateStatus_CertificateStatus = 1 +) + +// Enum value maps for DeviceCertificateStatus_CertificateStatus. +var ( + DeviceCertificateStatus_CertificateStatus_name = map[int32]string{ + 0: "VALID", + 1: "REVOKED", + } + DeviceCertificateStatus_CertificateStatus_value = map[string]int32{ + "VALID": 0, + "REVOKED": 1, + } +) + +func (x DeviceCertificateStatus_CertificateStatus) Enum() *DeviceCertificateStatus_CertificateStatus { + p := new(DeviceCertificateStatus_CertificateStatus) + *p = x + return p +} + +func (x DeviceCertificateStatus_CertificateStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (DeviceCertificateStatus_CertificateStatus) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[5].Descriptor() +} + +func (DeviceCertificateStatus_CertificateStatus) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[5] +} + +func (x DeviceCertificateStatus_CertificateStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *DeviceCertificateStatus_CertificateStatus) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = DeviceCertificateStatus_CertificateStatus(num) + return nil +} + +// Deprecated: Use DeviceCertificateStatus_CertificateStatus.Descriptor instead. +func (DeviceCertificateStatus_CertificateStatus) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{2, 0} +} + +type License_KeyContainer_KeyType int32 + +const ( + License_KeyContainer_SIGNING License_KeyContainer_KeyType = 1 + License_KeyContainer_CONTENT License_KeyContainer_KeyType = 2 + License_KeyContainer_KEY_CONTROL License_KeyContainer_KeyType = 3 + License_KeyContainer_OPERATOR_SESSION License_KeyContainer_KeyType = 4 +) + +// Enum value maps for License_KeyContainer_KeyType. +var ( + License_KeyContainer_KeyType_name = map[int32]string{ + 1: "SIGNING", + 2: "CONTENT", + 3: "KEY_CONTROL", + 4: "OPERATOR_SESSION", + } + License_KeyContainer_KeyType_value = map[string]int32{ + "SIGNING": 1, + "CONTENT": 2, + "KEY_CONTROL": 3, + "OPERATOR_SESSION": 4, + } +) + +func (x License_KeyContainer_KeyType) Enum() *License_KeyContainer_KeyType { + p := new(License_KeyContainer_KeyType) + *p = x + return p +} + +func (x License_KeyContainer_KeyType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (License_KeyContainer_KeyType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[6].Descriptor() +} + +func (License_KeyContainer_KeyType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[6] +} + +func (x License_KeyContainer_KeyType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *License_KeyContainer_KeyType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = License_KeyContainer_KeyType(num) + return nil +} + +// Deprecated: Use License_KeyContainer_KeyType.Descriptor instead. +func (License_KeyContainer_KeyType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6, 1, 0} +} + +type License_KeyContainer_SecurityLevel int32 + +const ( + License_KeyContainer_SW_SECURE_CRYPTO License_KeyContainer_SecurityLevel = 1 + License_KeyContainer_SW_SECURE_DECODE License_KeyContainer_SecurityLevel = 2 + License_KeyContainer_HW_SECURE_CRYPTO License_KeyContainer_SecurityLevel = 3 + License_KeyContainer_HW_SECURE_DECODE License_KeyContainer_SecurityLevel = 4 + License_KeyContainer_HW_SECURE_ALL License_KeyContainer_SecurityLevel = 5 +) + +// Enum value maps for License_KeyContainer_SecurityLevel. +var ( + License_KeyContainer_SecurityLevel_name = map[int32]string{ + 1: "SW_SECURE_CRYPTO", + 2: "SW_SECURE_DECODE", + 3: "HW_SECURE_CRYPTO", + 4: "HW_SECURE_DECODE", + 5: "HW_SECURE_ALL", + } + License_KeyContainer_SecurityLevel_value = map[string]int32{ + "SW_SECURE_CRYPTO": 1, + "SW_SECURE_DECODE": 2, + "HW_SECURE_CRYPTO": 3, + "HW_SECURE_DECODE": 4, + "HW_SECURE_ALL": 5, + } +) + +func (x License_KeyContainer_SecurityLevel) Enum() *License_KeyContainer_SecurityLevel { + p := new(License_KeyContainer_SecurityLevel) + *p = x + return p +} + +func (x License_KeyContainer_SecurityLevel) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (License_KeyContainer_SecurityLevel) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[7].Descriptor() +} + +func (License_KeyContainer_SecurityLevel) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[7] +} + +func (x License_KeyContainer_SecurityLevel) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *License_KeyContainer_SecurityLevel) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = License_KeyContainer_SecurityLevel(num) + return nil +} + +// Deprecated: Use License_KeyContainer_SecurityLevel.Descriptor instead. +func (License_KeyContainer_SecurityLevel) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6, 1, 1} +} + +type License_KeyContainer_OutputProtection_CGMS int32 + +const ( + License_KeyContainer_OutputProtection_COPY_FREE License_KeyContainer_OutputProtection_CGMS = 0 + License_KeyContainer_OutputProtection_COPY_ONCE License_KeyContainer_OutputProtection_CGMS = 2 + License_KeyContainer_OutputProtection_COPY_NEVER License_KeyContainer_OutputProtection_CGMS = 3 + License_KeyContainer_OutputProtection_CGMS_NONE License_KeyContainer_OutputProtection_CGMS = 42 // PC default! +) + +// Enum value maps for License_KeyContainer_OutputProtection_CGMS. +var ( + License_KeyContainer_OutputProtection_CGMS_name = map[int32]string{ + 0: "COPY_FREE", + 2: "COPY_ONCE", + 3: "COPY_NEVER", + 42: "CGMS_NONE", + } + License_KeyContainer_OutputProtection_CGMS_value = map[string]int32{ + "COPY_FREE": 0, + "COPY_ONCE": 2, + "COPY_NEVER": 3, + "CGMS_NONE": 42, + } +) + +func (x License_KeyContainer_OutputProtection_CGMS) Enum() *License_KeyContainer_OutputProtection_CGMS { + p := new(License_KeyContainer_OutputProtection_CGMS) + *p = x + return p +} + +func (x License_KeyContainer_OutputProtection_CGMS) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (License_KeyContainer_OutputProtection_CGMS) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[8].Descriptor() +} + +func (License_KeyContainer_OutputProtection_CGMS) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[8] +} + +func (x License_KeyContainer_OutputProtection_CGMS) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *License_KeyContainer_OutputProtection_CGMS) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = License_KeyContainer_OutputProtection_CGMS(num) + return nil +} + +// Deprecated: Use License_KeyContainer_OutputProtection_CGMS.Descriptor instead. +func (License_KeyContainer_OutputProtection_CGMS) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6, 1, 0, 0} +} + +type LicenseError_Error int32 + +const ( + LicenseError_INVALID_DEVICE_CERTIFICATE LicenseError_Error = 1 + LicenseError_REVOKED_DEVICE_CERTIFICATE LicenseError_Error = 2 + LicenseError_SERVICE_UNAVAILABLE LicenseError_Error = 3 +) + +// Enum value maps for LicenseError_Error. +var ( + LicenseError_Error_name = map[int32]string{ + 1: "INVALID_DEVICE_CERTIFICATE", + 2: "REVOKED_DEVICE_CERTIFICATE", + 3: "SERVICE_UNAVAILABLE", + } + LicenseError_Error_value = map[string]int32{ + "INVALID_DEVICE_CERTIFICATE": 1, + "REVOKED_DEVICE_CERTIFICATE": 2, + "SERVICE_UNAVAILABLE": 3, + } +) + +func (x LicenseError_Error) Enum() *LicenseError_Error { + p := new(LicenseError_Error) + *p = x + return p +} + +func (x LicenseError_Error) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (LicenseError_Error) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[9].Descriptor() +} + +func (LicenseError_Error) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[9] +} + +func (x LicenseError_Error) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *LicenseError_Error) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = LicenseError_Error(num) + return nil +} + +// Deprecated: Use LicenseError_Error.Descriptor instead. +func (LicenseError_Error) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{7, 0} +} + +type LicenseRequest_RequestType int32 + +const ( + LicenseRequest_NEW LicenseRequest_RequestType = 1 + LicenseRequest_RENEWAL LicenseRequest_RequestType = 2 + LicenseRequest_RELEASE LicenseRequest_RequestType = 3 +) + +// Enum value maps for LicenseRequest_RequestType. +var ( + LicenseRequest_RequestType_name = map[int32]string{ + 1: "NEW", + 2: "RENEWAL", + 3: "RELEASE", + } + LicenseRequest_RequestType_value = map[string]int32{ + "NEW": 1, + "RENEWAL": 2, + "RELEASE": 3, + } +) + +func (x LicenseRequest_RequestType) Enum() *LicenseRequest_RequestType { + p := new(LicenseRequest_RequestType) + *p = x + return p +} + +func (x LicenseRequest_RequestType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (LicenseRequest_RequestType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[10].Descriptor() +} + +func (LicenseRequest_RequestType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[10] +} + +func (x LicenseRequest_RequestType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *LicenseRequest_RequestType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = LicenseRequest_RequestType(num) + return nil +} + +// Deprecated: Use LicenseRequest_RequestType.Descriptor instead. +func (LicenseRequest_RequestType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{8, 0} +} + +type LicenseRequestRaw_RequestType int32 + +const ( + LicenseRequestRaw_NEW LicenseRequestRaw_RequestType = 1 + LicenseRequestRaw_RENEWAL LicenseRequestRaw_RequestType = 2 + LicenseRequestRaw_RELEASE LicenseRequestRaw_RequestType = 3 +) + +// Enum value maps for LicenseRequestRaw_RequestType. +var ( + LicenseRequestRaw_RequestType_name = map[int32]string{ + 1: "NEW", + 2: "RENEWAL", + 3: "RELEASE", + } + LicenseRequestRaw_RequestType_value = map[string]int32{ + "NEW": 1, + "RENEWAL": 2, + "RELEASE": 3, + } +) + +func (x LicenseRequestRaw_RequestType) Enum() *LicenseRequestRaw_RequestType { + p := new(LicenseRequestRaw_RequestType) + *p = x + return p +} + +func (x LicenseRequestRaw_RequestType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (LicenseRequestRaw_RequestType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[11].Descriptor() +} + +func (LicenseRequestRaw_RequestType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[11] +} + +func (x LicenseRequestRaw_RequestType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *LicenseRequestRaw_RequestType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = LicenseRequestRaw_RequestType(num) + return nil +} + +// Deprecated: Use LicenseRequestRaw_RequestType.Descriptor instead. +func (LicenseRequestRaw_RequestType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{9, 0} +} + +type ProvisionedDeviceInfo_WvSecurityLevel int32 + +const ( + ProvisionedDeviceInfo_LEVEL_UNSPECIFIED ProvisionedDeviceInfo_WvSecurityLevel = 0 + ProvisionedDeviceInfo_LEVEL_1 ProvisionedDeviceInfo_WvSecurityLevel = 1 + ProvisionedDeviceInfo_LEVEL_2 ProvisionedDeviceInfo_WvSecurityLevel = 2 + ProvisionedDeviceInfo_LEVEL_3 ProvisionedDeviceInfo_WvSecurityLevel = 3 +) + +// Enum value maps for ProvisionedDeviceInfo_WvSecurityLevel. +var ( + ProvisionedDeviceInfo_WvSecurityLevel_name = map[int32]string{ + 0: "LEVEL_UNSPECIFIED", + 1: "LEVEL_1", + 2: "LEVEL_2", + 3: "LEVEL_3", + } + ProvisionedDeviceInfo_WvSecurityLevel_value = map[string]int32{ + "LEVEL_UNSPECIFIED": 0, + "LEVEL_1": 1, + "LEVEL_2": 2, + "LEVEL_3": 3, + } +) + +func (x ProvisionedDeviceInfo_WvSecurityLevel) Enum() *ProvisionedDeviceInfo_WvSecurityLevel { + p := new(ProvisionedDeviceInfo_WvSecurityLevel) + *p = x + return p +} + +func (x ProvisionedDeviceInfo_WvSecurityLevel) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ProvisionedDeviceInfo_WvSecurityLevel) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[12].Descriptor() +} + +func (ProvisionedDeviceInfo_WvSecurityLevel) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[12] +} + +func (x ProvisionedDeviceInfo_WvSecurityLevel) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *ProvisionedDeviceInfo_WvSecurityLevel) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = ProvisionedDeviceInfo_WvSecurityLevel(num) + return nil +} + +// Deprecated: Use ProvisionedDeviceInfo_WvSecurityLevel.Descriptor instead. +func (ProvisionedDeviceInfo_WvSecurityLevel) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{10, 0} +} + +type SignedMessage_MessageType int32 + +const ( + SignedMessage_LICENSE_REQUEST SignedMessage_MessageType = 1 + SignedMessage_LICENSE SignedMessage_MessageType = 2 + SignedMessage_ERROR_RESPONSE SignedMessage_MessageType = 3 + SignedMessage_SERVICE_CERTIFICATE_REQUEST SignedMessage_MessageType = 4 + SignedMessage_SERVICE_CERTIFICATE SignedMessage_MessageType = 5 +) + +// Enum value maps for SignedMessage_MessageType. +var ( + SignedMessage_MessageType_name = map[int32]string{ + 1: "LICENSE_REQUEST", + 2: "LICENSE", + 3: "ERROR_RESPONSE", + 4: "SERVICE_CERTIFICATE_REQUEST", + 5: "SERVICE_CERTIFICATE", + } + SignedMessage_MessageType_value = map[string]int32{ + "LICENSE_REQUEST": 1, + "LICENSE": 2, + "ERROR_RESPONSE": 3, + "SERVICE_CERTIFICATE_REQUEST": 4, + "SERVICE_CERTIFICATE": 5, + } +) + +func (x SignedMessage_MessageType) Enum() *SignedMessage_MessageType { + p := new(SignedMessage_MessageType) + *p = x + return p +} + +func (x SignedMessage_MessageType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SignedMessage_MessageType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[13].Descriptor() +} + +func (SignedMessage_MessageType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[13] +} + +func (x SignedMessage_MessageType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *SignedMessage_MessageType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = SignedMessage_MessageType(num) + return nil +} + +// Deprecated: Use SignedMessage_MessageType.Descriptor instead. +func (SignedMessage_MessageType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{20, 0} +} + +type WidevineCencHeader_Algorithm int32 + +const ( + WidevineCencHeader_UNENCRYPTED WidevineCencHeader_Algorithm = 0 + WidevineCencHeader_AESCTR WidevineCencHeader_Algorithm = 1 +) + +// Enum value maps for WidevineCencHeader_Algorithm. +var ( + WidevineCencHeader_Algorithm_name = map[int32]string{ + 0: "UNENCRYPTED", + 1: "AESCTR", + } + WidevineCencHeader_Algorithm_value = map[string]int32{ + "UNENCRYPTED": 0, + "AESCTR": 1, + } +) + +func (x WidevineCencHeader_Algorithm) Enum() *WidevineCencHeader_Algorithm { + p := new(WidevineCencHeader_Algorithm) + *p = x + return p +} + +func (x WidevineCencHeader_Algorithm) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (WidevineCencHeader_Algorithm) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[14].Descriptor() +} + +func (WidevineCencHeader_Algorithm) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[14] +} + +func (x WidevineCencHeader_Algorithm) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *WidevineCencHeader_Algorithm) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = WidevineCencHeader_Algorithm(num) + return nil +} + +// Deprecated: Use WidevineCencHeader_Algorithm.Descriptor instead. +func (WidevineCencHeader_Algorithm) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{21, 0} +} + +type SignedLicenseRequest_MessageType int32 + +const ( + SignedLicenseRequest_LICENSE_REQUEST SignedLicenseRequest_MessageType = 1 + SignedLicenseRequest_LICENSE SignedLicenseRequest_MessageType = 2 + SignedLicenseRequest_ERROR_RESPONSE SignedLicenseRequest_MessageType = 3 + SignedLicenseRequest_SERVICE_CERTIFICATE_REQUEST SignedLicenseRequest_MessageType = 4 + SignedLicenseRequest_SERVICE_CERTIFICATE SignedLicenseRequest_MessageType = 5 +) + +// Enum value maps for SignedLicenseRequest_MessageType. +var ( + SignedLicenseRequest_MessageType_name = map[int32]string{ + 1: "LICENSE_REQUEST", + 2: "LICENSE", + 3: "ERROR_RESPONSE", + 4: "SERVICE_CERTIFICATE_REQUEST", + 5: "SERVICE_CERTIFICATE", + } + SignedLicenseRequest_MessageType_value = map[string]int32{ + "LICENSE_REQUEST": 1, + "LICENSE": 2, + "ERROR_RESPONSE": 3, + "SERVICE_CERTIFICATE_REQUEST": 4, + "SERVICE_CERTIFICATE": 5, + } +) + +func (x SignedLicenseRequest_MessageType) Enum() *SignedLicenseRequest_MessageType { + p := new(SignedLicenseRequest_MessageType) + *p = x + return p +} + +func (x SignedLicenseRequest_MessageType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SignedLicenseRequest_MessageType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[15].Descriptor() +} + +func (SignedLicenseRequest_MessageType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[15] +} + +func (x SignedLicenseRequest_MessageType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *SignedLicenseRequest_MessageType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = SignedLicenseRequest_MessageType(num) + return nil +} + +// Deprecated: Use SignedLicenseRequest_MessageType.Descriptor instead. +func (SignedLicenseRequest_MessageType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{22, 0} +} + +type SignedLicenseRequestRaw_MessageType int32 + +const ( + SignedLicenseRequestRaw_LICENSE_REQUEST SignedLicenseRequestRaw_MessageType = 1 + SignedLicenseRequestRaw_LICENSE SignedLicenseRequestRaw_MessageType = 2 + SignedLicenseRequestRaw_ERROR_RESPONSE SignedLicenseRequestRaw_MessageType = 3 + SignedLicenseRequestRaw_SERVICE_CERTIFICATE_REQUEST SignedLicenseRequestRaw_MessageType = 4 + SignedLicenseRequestRaw_SERVICE_CERTIFICATE SignedLicenseRequestRaw_MessageType = 5 +) + +// Enum value maps for SignedLicenseRequestRaw_MessageType. +var ( + SignedLicenseRequestRaw_MessageType_name = map[int32]string{ + 1: "LICENSE_REQUEST", + 2: "LICENSE", + 3: "ERROR_RESPONSE", + 4: "SERVICE_CERTIFICATE_REQUEST", + 5: "SERVICE_CERTIFICATE", + } + SignedLicenseRequestRaw_MessageType_value = map[string]int32{ + "LICENSE_REQUEST": 1, + "LICENSE": 2, + "ERROR_RESPONSE": 3, + "SERVICE_CERTIFICATE_REQUEST": 4, + "SERVICE_CERTIFICATE": 5, + } +) + +func (x SignedLicenseRequestRaw_MessageType) Enum() *SignedLicenseRequestRaw_MessageType { + p := new(SignedLicenseRequestRaw_MessageType) + *p = x + return p +} + +func (x SignedLicenseRequestRaw_MessageType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SignedLicenseRequestRaw_MessageType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[16].Descriptor() +} + +func (SignedLicenseRequestRaw_MessageType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[16] +} + +func (x SignedLicenseRequestRaw_MessageType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *SignedLicenseRequestRaw_MessageType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = SignedLicenseRequestRaw_MessageType(num) + return nil +} + +// Deprecated: Use SignedLicenseRequestRaw_MessageType.Descriptor instead. +func (SignedLicenseRequestRaw_MessageType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{23, 0} +} + +type SignedLicense_MessageType int32 + +const ( + SignedLicense_LICENSE_REQUEST SignedLicense_MessageType = 1 + SignedLicense_LICENSE SignedLicense_MessageType = 2 + SignedLicense_ERROR_RESPONSE SignedLicense_MessageType = 3 + SignedLicense_SERVICE_CERTIFICATE_REQUEST SignedLicense_MessageType = 4 + SignedLicense_SERVICE_CERTIFICATE SignedLicense_MessageType = 5 +) + +// Enum value maps for SignedLicense_MessageType. +var ( + SignedLicense_MessageType_name = map[int32]string{ + 1: "LICENSE_REQUEST", + 2: "LICENSE", + 3: "ERROR_RESPONSE", + 4: "SERVICE_CERTIFICATE_REQUEST", + 5: "SERVICE_CERTIFICATE", + } + SignedLicense_MessageType_value = map[string]int32{ + "LICENSE_REQUEST": 1, + "LICENSE": 2, + "ERROR_RESPONSE": 3, + "SERVICE_CERTIFICATE_REQUEST": 4, + "SERVICE_CERTIFICATE": 5, + } +) + +func (x SignedLicense_MessageType) Enum() *SignedLicense_MessageType { + p := new(SignedLicense_MessageType) + *p = x + return p +} + +func (x SignedLicense_MessageType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SignedLicense_MessageType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[17].Descriptor() +} + +func (SignedLicense_MessageType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[17] +} + +func (x SignedLicense_MessageType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *SignedLicense_MessageType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = SignedLicense_MessageType(num) + return nil +} + +// Deprecated: Use SignedLicense_MessageType.Descriptor instead. +func (SignedLicense_MessageType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{24, 0} +} + +type SignedServiceCertificate_MessageType int32 + +const ( + SignedServiceCertificate_LICENSE_REQUEST SignedServiceCertificate_MessageType = 1 + SignedServiceCertificate_LICENSE SignedServiceCertificate_MessageType = 2 + SignedServiceCertificate_ERROR_RESPONSE SignedServiceCertificate_MessageType = 3 + SignedServiceCertificate_SERVICE_CERTIFICATE_REQUEST SignedServiceCertificate_MessageType = 4 + SignedServiceCertificate_SERVICE_CERTIFICATE SignedServiceCertificate_MessageType = 5 +) + +// Enum value maps for SignedServiceCertificate_MessageType. +var ( + SignedServiceCertificate_MessageType_name = map[int32]string{ + 1: "LICENSE_REQUEST", + 2: "LICENSE", + 3: "ERROR_RESPONSE", + 4: "SERVICE_CERTIFICATE_REQUEST", + 5: "SERVICE_CERTIFICATE", + } + SignedServiceCertificate_MessageType_value = map[string]int32{ + "LICENSE_REQUEST": 1, + "LICENSE": 2, + "ERROR_RESPONSE": 3, + "SERVICE_CERTIFICATE_REQUEST": 4, + "SERVICE_CERTIFICATE": 5, + } +) + +func (x SignedServiceCertificate_MessageType) Enum() *SignedServiceCertificate_MessageType { + p := new(SignedServiceCertificate_MessageType) + *p = x + return p +} + +func (x SignedServiceCertificate_MessageType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SignedServiceCertificate_MessageType) Descriptor() protoreflect.EnumDescriptor { + return file_wv_proto2_proto_enumTypes[18].Descriptor() +} + +func (SignedServiceCertificate_MessageType) Type() protoreflect.EnumType { + return &file_wv_proto2_proto_enumTypes[18] +} + +func (x SignedServiceCertificate_MessageType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *SignedServiceCertificate_MessageType) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = SignedServiceCertificate_MessageType(num) + return nil +} + +// Deprecated: Use SignedServiceCertificate_MessageType.Descriptor instead. +func (SignedServiceCertificate_MessageType) EnumDescriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{25, 0} +} + +// from x86 (partial), most of it from the ARM version: +type ClientIdentification struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type *ClientIdentification_TokenType `protobuf:"varint,1,req,name=Type,enum=ClientIdentification_TokenType" json:"Type,omitempty"` + //optional bytes Token = 2; // by default the client treats this as blob, but it's usually a DeviceCertificate, so for usefulness sake, I'm replacing it with this one: + Token *SignedDeviceCertificate `protobuf:"bytes,2,opt,name=Token" json:"Token,omitempty"` // use this when parsing, "bytes" when building a client id blob + ClientInfo []*ClientIdentification_NameValue `protobuf:"bytes,3,rep,name=ClientInfo" json:"ClientInfo,omitempty"` + ProviderClientToken []byte `protobuf:"bytes,4,opt,name=ProviderClientToken" json:"ProviderClientToken,omitempty"` + LicenseCounter *uint32 `protobuf:"varint,5,opt,name=LicenseCounter" json:"LicenseCounter,omitempty"` + XClientCapabilities *ClientIdentification_ClientCapabilities `protobuf:"bytes,6,opt,name=_ClientCapabilities,json=ClientCapabilities" json:"_ClientCapabilities,omitempty"` // how should we deal with duped names? will have to look at proto docs later + XFileHashes *FileHashes `protobuf:"bytes,7,opt,name=_FileHashes,json=FileHashes" json:"_FileHashes,omitempty"` // vmp blob goes here +} + +func (x *ClientIdentification) Reset() { + *x = ClientIdentification{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClientIdentification) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientIdentification) ProtoMessage() {} + +func (x *ClientIdentification) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClientIdentification.ProtoReflect.Descriptor instead. +func (*ClientIdentification) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{0} +} + +func (x *ClientIdentification) GetType() ClientIdentification_TokenType { + if x != nil && x.Type != nil { + return *x.Type + } + return ClientIdentification_KEYBOX +} + +func (x *ClientIdentification) GetToken() *SignedDeviceCertificate { + if x != nil { + return x.Token + } + return nil +} + +func (x *ClientIdentification) GetClientInfo() []*ClientIdentification_NameValue { + if x != nil { + return x.ClientInfo + } + return nil +} + +func (x *ClientIdentification) GetProviderClientToken() []byte { + if x != nil { + return x.ProviderClientToken + } + return nil +} + +func (x *ClientIdentification) GetLicenseCounter() uint32 { + if x != nil && x.LicenseCounter != nil { + return *x.LicenseCounter + } + return 0 +} + +func (x *ClientIdentification) GetXClientCapabilities() *ClientIdentification_ClientCapabilities { + if x != nil { + return x.XClientCapabilities + } + return nil +} + +func (x *ClientIdentification) GetXFileHashes() *FileHashes { + if x != nil { + return x.XFileHashes + } + return nil +} + +type DeviceCertificate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type *DeviceCertificate_CertificateType `protobuf:"varint,1,req,name=Type,enum=DeviceCertificate_CertificateType" json:"Type,omitempty"` // the compiled code reused this as ProvisionedDeviceInfo.WvSecurityLevel, however that is incorrect (compiler aliased it as they're both identical as a structure) + SerialNumber []byte `protobuf:"bytes,2,opt,name=SerialNumber" json:"SerialNumber,omitempty"` + CreationTimeSeconds *uint32 `protobuf:"varint,3,opt,name=CreationTimeSeconds" json:"CreationTimeSeconds,omitempty"` + PublicKey []byte `protobuf:"bytes,4,opt,name=PublicKey" json:"PublicKey,omitempty"` + SystemId *uint32 `protobuf:"varint,5,opt,name=SystemId" json:"SystemId,omitempty"` + TestDeviceDeprecated *uint32 `protobuf:"varint,6,opt,name=TestDeviceDeprecated" json:"TestDeviceDeprecated,omitempty"` // is it bool or int? + ServiceId []byte `protobuf:"bytes,7,opt,name=ServiceId" json:"ServiceId,omitempty"` // service URL for service certificates +} + +func (x *DeviceCertificate) Reset() { + *x = DeviceCertificate{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeviceCertificate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeviceCertificate) ProtoMessage() {} + +func (x *DeviceCertificate) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeviceCertificate.ProtoReflect.Descriptor instead. +func (*DeviceCertificate) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{1} +} + +func (x *DeviceCertificate) GetType() DeviceCertificate_CertificateType { + if x != nil && x.Type != nil { + return *x.Type + } + return DeviceCertificate_ROOT +} + +func (x *DeviceCertificate) GetSerialNumber() []byte { + if x != nil { + return x.SerialNumber + } + return nil +} + +func (x *DeviceCertificate) GetCreationTimeSeconds() uint32 { + if x != nil && x.CreationTimeSeconds != nil { + return *x.CreationTimeSeconds + } + return 0 +} + +func (x *DeviceCertificate) GetPublicKey() []byte { + if x != nil { + return x.PublicKey + } + return nil +} + +func (x *DeviceCertificate) GetSystemId() uint32 { + if x != nil && x.SystemId != nil { + return *x.SystemId + } + return 0 +} + +func (x *DeviceCertificate) GetTestDeviceDeprecated() uint32 { + if x != nil && x.TestDeviceDeprecated != nil { + return *x.TestDeviceDeprecated + } + return 0 +} + +func (x *DeviceCertificate) GetServiceId() []byte { + if x != nil { + return x.ServiceId + } + return nil +} + +// missing some references, +type DeviceCertificateStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SerialNumber []byte `protobuf:"bytes,1,opt,name=SerialNumber" json:"SerialNumber,omitempty"` + Status *DeviceCertificateStatus_CertificateStatus `protobuf:"varint,2,opt,name=Status,enum=DeviceCertificateStatus_CertificateStatus" json:"Status,omitempty"` + DeviceInfo *ProvisionedDeviceInfo `protobuf:"bytes,4,opt,name=DeviceInfo" json:"DeviceInfo,omitempty"` // where is 3? is it deprecated? +} + +func (x *DeviceCertificateStatus) Reset() { + *x = DeviceCertificateStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeviceCertificateStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeviceCertificateStatus) ProtoMessage() {} + +func (x *DeviceCertificateStatus) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeviceCertificateStatus.ProtoReflect.Descriptor instead. +func (*DeviceCertificateStatus) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{2} +} + +func (x *DeviceCertificateStatus) GetSerialNumber() []byte { + if x != nil { + return x.SerialNumber + } + return nil +} + +func (x *DeviceCertificateStatus) GetStatus() DeviceCertificateStatus_CertificateStatus { + if x != nil && x.Status != nil { + return *x.Status + } + return DeviceCertificateStatus_VALID +} + +func (x *DeviceCertificateStatus) GetDeviceInfo() *ProvisionedDeviceInfo { + if x != nil { + return x.DeviceInfo + } + return nil +} + +type DeviceCertificateStatusList struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CreationTimeSeconds *uint32 `protobuf:"varint,1,opt,name=CreationTimeSeconds" json:"CreationTimeSeconds,omitempty"` + CertificateStatus []*DeviceCertificateStatus `protobuf:"bytes,2,rep,name=CertificateStatus" json:"CertificateStatus,omitempty"` +} + +func (x *DeviceCertificateStatusList) Reset() { + *x = DeviceCertificateStatusList{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeviceCertificateStatusList) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeviceCertificateStatusList) ProtoMessage() {} + +func (x *DeviceCertificateStatusList) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeviceCertificateStatusList.ProtoReflect.Descriptor instead. +func (*DeviceCertificateStatusList) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{3} +} + +func (x *DeviceCertificateStatusList) GetCreationTimeSeconds() uint32 { + if x != nil && x.CreationTimeSeconds != nil { + return *x.CreationTimeSeconds + } + return 0 +} + +func (x *DeviceCertificateStatusList) GetCertificateStatus() []*DeviceCertificateStatus { + if x != nil { + return x.CertificateStatus + } + return nil +} + +type EncryptedClientIdentification struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ServiceId *string `protobuf:"bytes,1,req,name=ServiceId" json:"ServiceId,omitempty"` + ServiceCertificateSerialNumber []byte `protobuf:"bytes,2,opt,name=ServiceCertificateSerialNumber" json:"ServiceCertificateSerialNumber,omitempty"` + EncryptedClientId []byte `protobuf:"bytes,3,req,name=EncryptedClientId" json:"EncryptedClientId,omitempty"` + EncryptedClientIdIv []byte `protobuf:"bytes,4,req,name=EncryptedClientIdIv" json:"EncryptedClientIdIv,omitempty"` + EncryptedPrivacyKey []byte `protobuf:"bytes,5,req,name=EncryptedPrivacyKey" json:"EncryptedPrivacyKey,omitempty"` +} + +func (x *EncryptedClientIdentification) Reset() { + *x = EncryptedClientIdentification{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EncryptedClientIdentification) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EncryptedClientIdentification) ProtoMessage() {} + +func (x *EncryptedClientIdentification) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EncryptedClientIdentification.ProtoReflect.Descriptor instead. +func (*EncryptedClientIdentification) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{4} +} + +func (x *EncryptedClientIdentification) GetServiceId() string { + if x != nil && x.ServiceId != nil { + return *x.ServiceId + } + return "" +} + +func (x *EncryptedClientIdentification) GetServiceCertificateSerialNumber() []byte { + if x != nil { + return x.ServiceCertificateSerialNumber + } + return nil +} + +func (x *EncryptedClientIdentification) GetEncryptedClientId() []byte { + if x != nil { + return x.EncryptedClientId + } + return nil +} + +func (x *EncryptedClientIdentification) GetEncryptedClientIdIv() []byte { + if x != nil { + return x.EncryptedClientIdIv + } + return nil +} + +func (x *EncryptedClientIdentification) GetEncryptedPrivacyKey() []byte { + if x != nil { + return x.EncryptedPrivacyKey + } + return nil +} + +type LicenseIdentification struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RequestId []byte `protobuf:"bytes,1,opt,name=RequestId" json:"RequestId,omitempty"` + SessionId []byte `protobuf:"bytes,2,opt,name=SessionId" json:"SessionId,omitempty"` + PurchaseId []byte `protobuf:"bytes,3,opt,name=PurchaseId" json:"PurchaseId,omitempty"` + Type *LicenseType `protobuf:"varint,4,opt,name=Type,enum=LicenseType" json:"Type,omitempty"` + Version *uint32 `protobuf:"varint,5,opt,name=Version" json:"Version,omitempty"` + ProviderSessionToken []byte `protobuf:"bytes,6,opt,name=ProviderSessionToken" json:"ProviderSessionToken,omitempty"` +} + +func (x *LicenseIdentification) Reset() { + *x = LicenseIdentification{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseIdentification) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseIdentification) ProtoMessage() {} + +func (x *LicenseIdentification) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseIdentification.ProtoReflect.Descriptor instead. +func (*LicenseIdentification) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{5} +} + +func (x *LicenseIdentification) GetRequestId() []byte { + if x != nil { + return x.RequestId + } + return nil +} + +func (x *LicenseIdentification) GetSessionId() []byte { + if x != nil { + return x.SessionId + } + return nil +} + +func (x *LicenseIdentification) GetPurchaseId() []byte { + if x != nil { + return x.PurchaseId + } + return nil +} + +func (x *LicenseIdentification) GetType() LicenseType { + if x != nil && x.Type != nil { + return *x.Type + } + return LicenseType_ZERO +} + +func (x *LicenseIdentification) GetVersion() uint32 { + if x != nil && x.Version != nil { + return *x.Version + } + return 0 +} + +func (x *LicenseIdentification) GetProviderSessionToken() []byte { + if x != nil { + return x.ProviderSessionToken + } + return nil +} + +type License struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id *LicenseIdentification `protobuf:"bytes,1,opt,name=Id" json:"Id,omitempty"` + XPolicy *License_Policy `protobuf:"bytes,2,opt,name=_Policy,json=Policy" json:"_Policy,omitempty"` // duped names, etc + Key []*License_KeyContainer `protobuf:"bytes,3,rep,name=Key" json:"Key,omitempty"` + LicenseStartTime *uint32 `protobuf:"varint,4,opt,name=LicenseStartTime" json:"LicenseStartTime,omitempty"` + RemoteAttestationVerified *uint32 `protobuf:"varint,5,opt,name=RemoteAttestationVerified" json:"RemoteAttestationVerified,omitempty"` // bool? + ProviderClientToken []byte `protobuf:"bytes,6,opt,name=ProviderClientToken" json:"ProviderClientToken,omitempty"` + // there might be more, check with newer versions (I see field 7-8 in a lic) + // this appeared in latest x86: + ProtectionScheme *uint32 `protobuf:"varint,7,opt,name=ProtectionScheme" json:"ProtectionScheme,omitempty"` // type unconfirmed fully, but it's likely as WidevineCencHeader describesit (fourcc) +} + +func (x *License) Reset() { + *x = License{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *License) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*License) ProtoMessage() {} + +func (x *License) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use License.ProtoReflect.Descriptor instead. +func (*License) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6} +} + +func (x *License) GetId() *LicenseIdentification { + if x != nil { + return x.Id + } + return nil +} + +func (x *License) GetXPolicy() *License_Policy { + if x != nil { + return x.XPolicy + } + return nil +} + +func (x *License) GetKey() []*License_KeyContainer { + if x != nil { + return x.Key + } + return nil +} + +func (x *License) GetLicenseStartTime() uint32 { + if x != nil && x.LicenseStartTime != nil { + return *x.LicenseStartTime + } + return 0 +} + +func (x *License) GetRemoteAttestationVerified() uint32 { + if x != nil && x.RemoteAttestationVerified != nil { + return *x.RemoteAttestationVerified + } + return 0 +} + +func (x *License) GetProviderClientToken() []byte { + if x != nil { + return x.ProviderClientToken + } + return nil +} + +func (x *License) GetProtectionScheme() uint32 { + if x != nil && x.ProtectionScheme != nil { + return *x.ProtectionScheme + } + return 0 +} + +type LicenseError struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + //LicenseRequest.RequestType ErrorCode; // clang mismatch + ErrorCode *LicenseError_Error `protobuf:"varint,1,opt,name=ErrorCode,enum=LicenseError_Error" json:"ErrorCode,omitempty"` +} + +func (x *LicenseError) Reset() { + *x = LicenseError{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseError) ProtoMessage() {} + +func (x *LicenseError) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseError.ProtoReflect.Descriptor instead. +func (*LicenseError) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{7} +} + +func (x *LicenseError) GetErrorCode() LicenseError_Error { + if x != nil && x.ErrorCode != nil { + return *x.ErrorCode + } + return LicenseError_INVALID_DEVICE_CERTIFICATE +} + +type LicenseRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ClientId *ClientIdentification `protobuf:"bytes,1,opt,name=ClientId" json:"ClientId,omitempty"` + ContentId *LicenseRequest_ContentIdentification `protobuf:"bytes,2,opt,name=ContentId" json:"ContentId,omitempty"` + Type *LicenseRequest_RequestType `protobuf:"varint,3,opt,name=Type,enum=LicenseRequest_RequestType" json:"Type,omitempty"` + RequestTime *uint32 `protobuf:"varint,4,opt,name=RequestTime" json:"RequestTime,omitempty"` + KeyControlNonceDeprecated []byte `protobuf:"bytes,5,opt,name=KeyControlNonceDeprecated" json:"KeyControlNonceDeprecated,omitempty"` + ProtocolVersion *ProtocolVersion `protobuf:"varint,6,opt,name=ProtocolVersion,enum=ProtocolVersion" json:"ProtocolVersion,omitempty"` // lacking symbols for this + KeyControlNonce *uint32 `protobuf:"varint,7,opt,name=KeyControlNonce" json:"KeyControlNonce,omitempty"` + EncryptedClientId *EncryptedClientIdentification `protobuf:"bytes,8,opt,name=EncryptedClientId" json:"EncryptedClientId,omitempty"` +} + +func (x *LicenseRequest) Reset() { + *x = LicenseRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequest) ProtoMessage() {} + +func (x *LicenseRequest) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequest.ProtoReflect.Descriptor instead. +func (*LicenseRequest) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{8} +} + +func (x *LicenseRequest) GetClientId() *ClientIdentification { + if x != nil { + return x.ClientId + } + return nil +} + +func (x *LicenseRequest) GetContentId() *LicenseRequest_ContentIdentification { + if x != nil { + return x.ContentId + } + return nil +} + +func (x *LicenseRequest) GetType() LicenseRequest_RequestType { + if x != nil && x.Type != nil { + return *x.Type + } + return LicenseRequest_NEW +} + +func (x *LicenseRequest) GetRequestTime() uint32 { + if x != nil && x.RequestTime != nil { + return *x.RequestTime + } + return 0 +} + +func (x *LicenseRequest) GetKeyControlNonceDeprecated() []byte { + if x != nil { + return x.KeyControlNonceDeprecated + } + return nil +} + +func (x *LicenseRequest) GetProtocolVersion() ProtocolVersion { + if x != nil && x.ProtocolVersion != nil { + return *x.ProtocolVersion + } + return ProtocolVersion_CURRENT +} + +func (x *LicenseRequest) GetKeyControlNonce() uint32 { + if x != nil && x.KeyControlNonce != nil { + return *x.KeyControlNonce + } + return 0 +} + +func (x *LicenseRequest) GetEncryptedClientId() *EncryptedClientIdentification { + if x != nil { + return x.EncryptedClientId + } + return nil +} + +// raw pssh hack +type LicenseRequestRaw struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ClientId *ClientIdentification `protobuf:"bytes,1,opt,name=ClientId" json:"ClientId,omitempty"` + ContentId *LicenseRequestRaw_ContentIdentification `protobuf:"bytes,2,opt,name=ContentId" json:"ContentId,omitempty"` + Type *LicenseRequestRaw_RequestType `protobuf:"varint,3,opt,name=Type,enum=LicenseRequestRaw_RequestType" json:"Type,omitempty"` + RequestTime *uint32 `protobuf:"varint,4,opt,name=RequestTime" json:"RequestTime,omitempty"` + KeyControlNonceDeprecated []byte `protobuf:"bytes,5,opt,name=KeyControlNonceDeprecated" json:"KeyControlNonceDeprecated,omitempty"` + ProtocolVersion *ProtocolVersion `protobuf:"varint,6,opt,name=ProtocolVersion,enum=ProtocolVersion" json:"ProtocolVersion,omitempty"` // lacking symbols for this + KeyControlNonce *uint32 `protobuf:"varint,7,opt,name=KeyControlNonce" json:"KeyControlNonce,omitempty"` + EncryptedClientId *EncryptedClientIdentification `protobuf:"bytes,8,opt,name=EncryptedClientId" json:"EncryptedClientId,omitempty"` +} + +func (x *LicenseRequestRaw) Reset() { + *x = LicenseRequestRaw{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequestRaw) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequestRaw) ProtoMessage() {} + +func (x *LicenseRequestRaw) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequestRaw.ProtoReflect.Descriptor instead. +func (*LicenseRequestRaw) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{9} +} + +func (x *LicenseRequestRaw) GetClientId() *ClientIdentification { + if x != nil { + return x.ClientId + } + return nil +} + +func (x *LicenseRequestRaw) GetContentId() *LicenseRequestRaw_ContentIdentification { + if x != nil { + return x.ContentId + } + return nil +} + +func (x *LicenseRequestRaw) GetType() LicenseRequestRaw_RequestType { + if x != nil && x.Type != nil { + return *x.Type + } + return LicenseRequestRaw_NEW +} + +func (x *LicenseRequestRaw) GetRequestTime() uint32 { + if x != nil && x.RequestTime != nil { + return *x.RequestTime + } + return 0 +} + +func (x *LicenseRequestRaw) GetKeyControlNonceDeprecated() []byte { + if x != nil { + return x.KeyControlNonceDeprecated + } + return nil +} + +func (x *LicenseRequestRaw) GetProtocolVersion() ProtocolVersion { + if x != nil && x.ProtocolVersion != nil { + return *x.ProtocolVersion + } + return ProtocolVersion_CURRENT +} + +func (x *LicenseRequestRaw) GetKeyControlNonce() uint32 { + if x != nil && x.KeyControlNonce != nil { + return *x.KeyControlNonce + } + return 0 +} + +func (x *LicenseRequestRaw) GetEncryptedClientId() *EncryptedClientIdentification { + if x != nil { + return x.EncryptedClientId + } + return nil +} + +type ProvisionedDeviceInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SystemId *uint32 `protobuf:"varint,1,opt,name=SystemId" json:"SystemId,omitempty"` + Soc *string `protobuf:"bytes,2,opt,name=Soc" json:"Soc,omitempty"` + Manufacturer *string `protobuf:"bytes,3,opt,name=Manufacturer" json:"Manufacturer,omitempty"` + Model *string `protobuf:"bytes,4,opt,name=Model" json:"Model,omitempty"` + DeviceType *string `protobuf:"bytes,5,opt,name=DeviceType" json:"DeviceType,omitempty"` + ModelYear *uint32 `protobuf:"varint,6,opt,name=ModelYear" json:"ModelYear,omitempty"` + SecurityLevel *ProvisionedDeviceInfo_WvSecurityLevel `protobuf:"varint,7,opt,name=SecurityLevel,enum=ProvisionedDeviceInfo_WvSecurityLevel" json:"SecurityLevel,omitempty"` + TestDevice *uint32 `protobuf:"varint,8,opt,name=TestDevice" json:"TestDevice,omitempty"` // bool? +} + +func (x *ProvisionedDeviceInfo) Reset() { + *x = ProvisionedDeviceInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProvisionedDeviceInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProvisionedDeviceInfo) ProtoMessage() {} + +func (x *ProvisionedDeviceInfo) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProvisionedDeviceInfo.ProtoReflect.Descriptor instead. +func (*ProvisionedDeviceInfo) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{10} +} + +func (x *ProvisionedDeviceInfo) GetSystemId() uint32 { + if x != nil && x.SystemId != nil { + return *x.SystemId + } + return 0 +} + +func (x *ProvisionedDeviceInfo) GetSoc() string { + if x != nil && x.Soc != nil { + return *x.Soc + } + return "" +} + +func (x *ProvisionedDeviceInfo) GetManufacturer() string { + if x != nil && x.Manufacturer != nil { + return *x.Manufacturer + } + return "" +} + +func (x *ProvisionedDeviceInfo) GetModel() string { + if x != nil && x.Model != nil { + return *x.Model + } + return "" +} + +func (x *ProvisionedDeviceInfo) GetDeviceType() string { + if x != nil && x.DeviceType != nil { + return *x.DeviceType + } + return "" +} + +func (x *ProvisionedDeviceInfo) GetModelYear() uint32 { + if x != nil && x.ModelYear != nil { + return *x.ModelYear + } + return 0 +} + +func (x *ProvisionedDeviceInfo) GetSecurityLevel() ProvisionedDeviceInfo_WvSecurityLevel { + if x != nil && x.SecurityLevel != nil { + return *x.SecurityLevel + } + return ProvisionedDeviceInfo_LEVEL_UNSPECIFIED +} + +func (x *ProvisionedDeviceInfo) GetTestDevice() uint32 { + if x != nil && x.TestDevice != nil { + return *x.TestDevice + } + return 0 +} + +// todo: fill +type ProvisioningOptions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *ProvisioningOptions) Reset() { + *x = ProvisioningOptions{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProvisioningOptions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProvisioningOptions) ProtoMessage() {} + +func (x *ProvisioningOptions) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProvisioningOptions.ProtoReflect.Descriptor instead. +func (*ProvisioningOptions) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{11} +} + +// todo: fill +type ProvisioningRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *ProvisioningRequest) Reset() { + *x = ProvisioningRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProvisioningRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProvisioningRequest) ProtoMessage() {} + +func (x *ProvisioningRequest) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProvisioningRequest.ProtoReflect.Descriptor instead. +func (*ProvisioningRequest) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{12} +} + +// todo: fill +type ProvisioningResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *ProvisioningResponse) Reset() { + *x = ProvisioningResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProvisioningResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProvisioningResponse) ProtoMessage() {} + +func (x *ProvisioningResponse) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProvisioningResponse.ProtoReflect.Descriptor instead. +func (*ProvisioningResponse) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{13} +} + +type RemoteAttestation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Certificate *EncryptedClientIdentification `protobuf:"bytes,1,opt,name=Certificate" json:"Certificate,omitempty"` + Salt *string `protobuf:"bytes,2,opt,name=Salt" json:"Salt,omitempty"` + Signature *string `protobuf:"bytes,3,opt,name=Signature" json:"Signature,omitempty"` +} + +func (x *RemoteAttestation) Reset() { + *x = RemoteAttestation{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RemoteAttestation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RemoteAttestation) ProtoMessage() {} + +func (x *RemoteAttestation) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RemoteAttestation.ProtoReflect.Descriptor instead. +func (*RemoteAttestation) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{14} +} + +func (x *RemoteAttestation) GetCertificate() *EncryptedClientIdentification { + if x != nil { + return x.Certificate + } + return nil +} + +func (x *RemoteAttestation) GetSalt() string { + if x != nil && x.Salt != nil { + return *x.Salt + } + return "" +} + +func (x *RemoteAttestation) GetSignature() string { + if x != nil && x.Signature != nil { + return *x.Signature + } + return "" +} + +// todo: fill +type SessionInit struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *SessionInit) Reset() { + *x = SessionInit{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SessionInit) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SessionInit) ProtoMessage() {} + +func (x *SessionInit) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SessionInit.ProtoReflect.Descriptor instead. +func (*SessionInit) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{15} +} + +// todo: fill +type SessionState struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *SessionState) Reset() { + *x = SessionState{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SessionState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SessionState) ProtoMessage() {} + +func (x *SessionState) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SessionState.ProtoReflect.Descriptor instead. +func (*SessionState) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{16} +} + +// todo: fill +type SignedCertificateStatusList struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *SignedCertificateStatusList) Reset() { + *x = SignedCertificateStatusList{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignedCertificateStatusList) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignedCertificateStatusList) ProtoMessage() {} + +func (x *SignedCertificateStatusList) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignedCertificateStatusList.ProtoReflect.Descriptor instead. +func (*SignedCertificateStatusList) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{17} +} + +type SignedDeviceCertificate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + //optional bytes DeviceCertificate = 1; // again, they use a buffer where it's supposed to be a message, so we'll replace it with what it really is: + XDeviceCertificate *DeviceCertificate `protobuf:"bytes,1,opt,name=_DeviceCertificate,json=DeviceCertificate" json:"_DeviceCertificate,omitempty"` // how should we deal with duped names? will have to look at proto docs later + Signature []byte `protobuf:"bytes,2,opt,name=Signature" json:"Signature,omitempty"` + Signer *SignedDeviceCertificate `protobuf:"bytes,3,opt,name=Signer" json:"Signer,omitempty"` +} + +func (x *SignedDeviceCertificate) Reset() { + *x = SignedDeviceCertificate{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignedDeviceCertificate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignedDeviceCertificate) ProtoMessage() {} + +func (x *SignedDeviceCertificate) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignedDeviceCertificate.ProtoReflect.Descriptor instead. +func (*SignedDeviceCertificate) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{18} +} + +func (x *SignedDeviceCertificate) GetXDeviceCertificate() *DeviceCertificate { + if x != nil { + return x.XDeviceCertificate + } + return nil +} + +func (x *SignedDeviceCertificate) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +func (x *SignedDeviceCertificate) GetSigner() *SignedDeviceCertificate { + if x != nil { + return x.Signer + } + return nil +} + +// todo: fill +type SignedProvisioningMessage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *SignedProvisioningMessage) Reset() { + *x = SignedProvisioningMessage{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignedProvisioningMessage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignedProvisioningMessage) ProtoMessage() {} + +func (x *SignedProvisioningMessage) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignedProvisioningMessage.ProtoReflect.Descriptor instead. +func (*SignedProvisioningMessage) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{19} +} + +// the root of all messages, from either server or client +type SignedMessage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type *SignedMessage_MessageType `protobuf:"varint,1,opt,name=Type,enum=SignedMessage_MessageType" json:"Type,omitempty"` // has in incorrect overlap with License_KeyContainer_SecurityLevel + Msg []byte `protobuf:"bytes,2,opt,name=Msg" json:"Msg,omitempty"` // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + Signature []byte `protobuf:"bytes,3,opt,name=Signature" json:"Signature,omitempty"` // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + SessionKey []byte `protobuf:"bytes,4,opt,name=SessionKey" json:"SessionKey,omitempty"` // often RSA wrapped for licenses + RemoteAttestation *RemoteAttestation `protobuf:"bytes,5,opt,name=RemoteAttestation" json:"RemoteAttestation,omitempty"` +} + +func (x *SignedMessage) Reset() { + *x = SignedMessage{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignedMessage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignedMessage) ProtoMessage() {} + +func (x *SignedMessage) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignedMessage.ProtoReflect.Descriptor instead. +func (*SignedMessage) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{20} +} + +func (x *SignedMessage) GetType() SignedMessage_MessageType { + if x != nil && x.Type != nil { + return *x.Type + } + return SignedMessage_LICENSE_REQUEST +} + +func (x *SignedMessage) GetMsg() []byte { + if x != nil { + return x.Msg + } + return nil +} + +func (x *SignedMessage) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +func (x *SignedMessage) GetSessionKey() []byte { + if x != nil { + return x.SessionKey + } + return nil +} + +func (x *SignedMessage) GetRemoteAttestation() *RemoteAttestation { + if x != nil { + return x.RemoteAttestation + } + return nil +} + +// This message is copied from google's docs, not reversed: +type WidevineCencHeader struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Algorithm *WidevineCencHeader_Algorithm `protobuf:"varint,1,opt,name=algorithm,enum=WidevineCencHeader_Algorithm" json:"algorithm,omitempty"` + KeyId [][]byte `protobuf:"bytes,2,rep,name=key_id,json=keyId" json:"key_id,omitempty"` + // Content provider name. + Provider *string `protobuf:"bytes,3,opt,name=provider" json:"provider,omitempty"` + // A content identifier, specified by content provider. + ContentId []byte `protobuf:"bytes,4,opt,name=content_id,json=contentId" json:"content_id,omitempty"` + // Track type. Acceptable values are SD, HD and AUDIO. Used to + // differentiate content keys used by an asset. + TrackTypeDeprecated *string `protobuf:"bytes,5,opt,name=track_type_deprecated,json=trackTypeDeprecated" json:"track_type_deprecated,omitempty"` + // The name of a registered policy to be used for this asset. + Policy *string `protobuf:"bytes,6,opt,name=policy" json:"policy,omitempty"` + // Crypto period index, for media using key rotation. + CryptoPeriodIndex *uint32 `protobuf:"varint,7,opt,name=crypto_period_index,json=cryptoPeriodIndex" json:"crypto_period_index,omitempty"` + // Optional protected context for group content. The grouped_license is a + // serialized SignedMessage. + GroupedLicense []byte `protobuf:"bytes,8,opt,name=grouped_license,json=groupedLicense" json:"grouped_license,omitempty"` + // Protection scheme identifying the encryption algorithm. + // Represented as one of the following 4CC values: + // 'cenc' (AESCTR), 'cbc1' (AESCBC), + // 'cens' (AESCTR subsample), 'cbcs' (AESCBC subsample). + ProtectionScheme *uint32 `protobuf:"varint,9,opt,name=protection_scheme,json=protectionScheme" json:"protection_scheme,omitempty"` + // Optional. For media using key rotation, this represents the duration + // of each crypto period in seconds. + CryptoPeriodSeconds *uint32 `protobuf:"varint,10,opt,name=crypto_period_seconds,json=cryptoPeriodSeconds" json:"crypto_period_seconds,omitempty"` +} + +func (x *WidevineCencHeader) Reset() { + *x = WidevineCencHeader{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WidevineCencHeader) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WidevineCencHeader) ProtoMessage() {} + +func (x *WidevineCencHeader) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WidevineCencHeader.ProtoReflect.Descriptor instead. +func (*WidevineCencHeader) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{21} +} + +func (x *WidevineCencHeader) GetAlgorithm() WidevineCencHeader_Algorithm { + if x != nil && x.Algorithm != nil { + return *x.Algorithm + } + return WidevineCencHeader_UNENCRYPTED +} + +func (x *WidevineCencHeader) GetKeyId() [][]byte { + if x != nil { + return x.KeyId + } + return nil +} + +func (x *WidevineCencHeader) GetProvider() string { + if x != nil && x.Provider != nil { + return *x.Provider + } + return "" +} + +func (x *WidevineCencHeader) GetContentId() []byte { + if x != nil { + return x.ContentId + } + return nil +} + +func (x *WidevineCencHeader) GetTrackTypeDeprecated() string { + if x != nil && x.TrackTypeDeprecated != nil { + return *x.TrackTypeDeprecated + } + return "" +} + +func (x *WidevineCencHeader) GetPolicy() string { + if x != nil && x.Policy != nil { + return *x.Policy + } + return "" +} + +func (x *WidevineCencHeader) GetCryptoPeriodIndex() uint32 { + if x != nil && x.CryptoPeriodIndex != nil { + return *x.CryptoPeriodIndex + } + return 0 +} + +func (x *WidevineCencHeader) GetGroupedLicense() []byte { + if x != nil { + return x.GroupedLicense + } + return nil +} + +func (x *WidevineCencHeader) GetProtectionScheme() uint32 { + if x != nil && x.ProtectionScheme != nil { + return *x.ProtectionScheme + } + return 0 +} + +func (x *WidevineCencHeader) GetCryptoPeriodSeconds() uint32 { + if x != nil && x.CryptoPeriodSeconds != nil { + return *x.CryptoPeriodSeconds + } + return 0 +} + +// from here on, it's just for testing, these messages don't exist in the binaries, I'm adding them to avoid detecting type programmatically +type SignedLicenseRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type *SignedLicenseRequest_MessageType `protobuf:"varint,1,opt,name=Type,enum=SignedLicenseRequest_MessageType" json:"Type,omitempty"` // has in incorrect overlap with License_KeyContainer_SecurityLevel + Msg *LicenseRequest `protobuf:"bytes,2,opt,name=Msg" json:"Msg,omitempty"` // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + Signature []byte `protobuf:"bytes,3,opt,name=Signature" json:"Signature,omitempty"` // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + SessionKey []byte `protobuf:"bytes,4,opt,name=SessionKey" json:"SessionKey,omitempty"` // often RSA wrapped for licenses + RemoteAttestation *RemoteAttestation `protobuf:"bytes,5,opt,name=RemoteAttestation" json:"RemoteAttestation,omitempty"` +} + +func (x *SignedLicenseRequest) Reset() { + *x = SignedLicenseRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignedLicenseRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignedLicenseRequest) ProtoMessage() {} + +func (x *SignedLicenseRequest) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignedLicenseRequest.ProtoReflect.Descriptor instead. +func (*SignedLicenseRequest) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{22} +} + +func (x *SignedLicenseRequest) GetType() SignedLicenseRequest_MessageType { + if x != nil && x.Type != nil { + return *x.Type + } + return SignedLicenseRequest_LICENSE_REQUEST +} + +func (x *SignedLicenseRequest) GetMsg() *LicenseRequest { + if x != nil { + return x.Msg + } + return nil +} + +func (x *SignedLicenseRequest) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +func (x *SignedLicenseRequest) GetSessionKey() []byte { + if x != nil { + return x.SessionKey + } + return nil +} + +func (x *SignedLicenseRequest) GetRemoteAttestation() *RemoteAttestation { + if x != nil { + return x.RemoteAttestation + } + return nil +} + +// hack +type SignedLicenseRequestRaw struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type *SignedLicenseRequestRaw_MessageType `protobuf:"varint,1,opt,name=Type,enum=SignedLicenseRequestRaw_MessageType" json:"Type,omitempty"` // has in incorrect overlap with License_KeyContainer_SecurityLevel + Msg *LicenseRequestRaw `protobuf:"bytes,2,opt,name=Msg" json:"Msg,omitempty"` // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + Signature []byte `protobuf:"bytes,3,opt,name=Signature" json:"Signature,omitempty"` // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + SessionKey []byte `protobuf:"bytes,4,opt,name=SessionKey" json:"SessionKey,omitempty"` // often RSA wrapped for licenses + RemoteAttestation *RemoteAttestation `protobuf:"bytes,5,opt,name=RemoteAttestation" json:"RemoteAttestation,omitempty"` +} + +func (x *SignedLicenseRequestRaw) Reset() { + *x = SignedLicenseRequestRaw{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignedLicenseRequestRaw) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignedLicenseRequestRaw) ProtoMessage() {} + +func (x *SignedLicenseRequestRaw) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignedLicenseRequestRaw.ProtoReflect.Descriptor instead. +func (*SignedLicenseRequestRaw) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{23} +} + +func (x *SignedLicenseRequestRaw) GetType() SignedLicenseRequestRaw_MessageType { + if x != nil && x.Type != nil { + return *x.Type + } + return SignedLicenseRequestRaw_LICENSE_REQUEST +} + +func (x *SignedLicenseRequestRaw) GetMsg() *LicenseRequestRaw { + if x != nil { + return x.Msg + } + return nil +} + +func (x *SignedLicenseRequestRaw) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +func (x *SignedLicenseRequestRaw) GetSessionKey() []byte { + if x != nil { + return x.SessionKey + } + return nil +} + +func (x *SignedLicenseRequestRaw) GetRemoteAttestation() *RemoteAttestation { + if x != nil { + return x.RemoteAttestation + } + return nil +} + +type SignedLicense struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type *SignedLicense_MessageType `protobuf:"varint,1,opt,name=Type,enum=SignedLicense_MessageType" json:"Type,omitempty"` // has in incorrect overlap with License_KeyContainer_SecurityLevel + Msg *License `protobuf:"bytes,2,opt,name=Msg" json:"Msg,omitempty"` // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + Signature []byte `protobuf:"bytes,3,opt,name=Signature" json:"Signature,omitempty"` // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + SessionKey []byte `protobuf:"bytes,4,opt,name=SessionKey" json:"SessionKey,omitempty"` // often RSA wrapped for licenses + RemoteAttestation *RemoteAttestation `protobuf:"bytes,5,opt,name=RemoteAttestation" json:"RemoteAttestation,omitempty"` +} + +func (x *SignedLicense) Reset() { + *x = SignedLicense{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignedLicense) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignedLicense) ProtoMessage() {} + +func (x *SignedLicense) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignedLicense.ProtoReflect.Descriptor instead. +func (*SignedLicense) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{24} +} + +func (x *SignedLicense) GetType() SignedLicense_MessageType { + if x != nil && x.Type != nil { + return *x.Type + } + return SignedLicense_LICENSE_REQUEST +} + +func (x *SignedLicense) GetMsg() *License { + if x != nil { + return x.Msg + } + return nil +} + +func (x *SignedLicense) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +func (x *SignedLicense) GetSessionKey() []byte { + if x != nil { + return x.SessionKey + } + return nil +} + +func (x *SignedLicense) GetRemoteAttestation() *RemoteAttestation { + if x != nil { + return x.RemoteAttestation + } + return nil +} + +type SignedServiceCertificate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type *SignedServiceCertificate_MessageType `protobuf:"varint,1,opt,name=Type,enum=SignedServiceCertificate_MessageType" json:"Type,omitempty"` // has in incorrect overlap with License_KeyContainer_SecurityLevel + Msg *SignedDeviceCertificate `protobuf:"bytes,2,opt,name=Msg" json:"Msg,omitempty"` // this has to be casted dynamically, to LicenseRequest, License or LicenseError (? unconfirmed), for Request, no other fields but Type need to be present + // for SERVICE_CERTIFICATE, only Type and Msg are present, and it's just a DeviceCertificate with CertificateType set to SERVICE + Signature []byte `protobuf:"bytes,3,opt,name=Signature" json:"Signature,omitempty"` // might be different type of signatures (ex. RSA vs AES CMAC(??), unconfirmed for now) + SessionKey []byte `protobuf:"bytes,4,opt,name=SessionKey" json:"SessionKey,omitempty"` // often RSA wrapped for licenses + RemoteAttestation *RemoteAttestation `protobuf:"bytes,5,opt,name=RemoteAttestation" json:"RemoteAttestation,omitempty"` +} + +func (x *SignedServiceCertificate) Reset() { + *x = SignedServiceCertificate{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SignedServiceCertificate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignedServiceCertificate) ProtoMessage() {} + +func (x *SignedServiceCertificate) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[25] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignedServiceCertificate.ProtoReflect.Descriptor instead. +func (*SignedServiceCertificate) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{25} +} + +func (x *SignedServiceCertificate) GetType() SignedServiceCertificate_MessageType { + if x != nil && x.Type != nil { + return *x.Type + } + return SignedServiceCertificate_LICENSE_REQUEST +} + +func (x *SignedServiceCertificate) GetMsg() *SignedDeviceCertificate { + if x != nil { + return x.Msg + } + return nil +} + +func (x *SignedServiceCertificate) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +func (x *SignedServiceCertificate) GetSessionKey() []byte { + if x != nil { + return x.SessionKey + } + return nil +} + +func (x *SignedServiceCertificate) GetRemoteAttestation() *RemoteAttestation { + if x != nil { + return x.RemoteAttestation + } + return nil +} + +//vmp support +type FileHashes struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Signer []byte `protobuf:"bytes,1,opt,name=signer" json:"signer,omitempty"` + Signatures []*FileHashes_Signature `protobuf:"bytes,2,rep,name=signatures" json:"signatures,omitempty"` +} + +func (x *FileHashes) Reset() { + *x = FileHashes{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FileHashes) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileHashes) ProtoMessage() {} + +func (x *FileHashes) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[26] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FileHashes.ProtoReflect.Descriptor instead. +func (*FileHashes) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{26} +} + +func (x *FileHashes) GetSigner() []byte { + if x != nil { + return x.Signer + } + return nil +} + +func (x *FileHashes) GetSignatures() []*FileHashes_Signature { + if x != nil { + return x.Signatures + } + return nil +} + +type ClientIdentification_NameValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + Value *string `protobuf:"bytes,2,req,name=Value" json:"Value,omitempty"` +} + +func (x *ClientIdentification_NameValue) Reset() { + *x = ClientIdentification_NameValue{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClientIdentification_NameValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientIdentification_NameValue) ProtoMessage() {} + +func (x *ClientIdentification_NameValue) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[27] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClientIdentification_NameValue.ProtoReflect.Descriptor instead. +func (*ClientIdentification_NameValue) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{0, 0} +} + +func (x *ClientIdentification_NameValue) GetName() string { + if x != nil && x.Name != nil { + return *x.Name + } + return "" +} + +func (x *ClientIdentification_NameValue) GetValue() string { + if x != nil && x.Value != nil { + return *x.Value + } + return "" +} + +type ClientIdentification_ClientCapabilities struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ClientToken *uint32 `protobuf:"varint,1,opt,name=ClientToken" json:"ClientToken,omitempty"` + SessionToken *uint32 `protobuf:"varint,2,opt,name=SessionToken" json:"SessionToken,omitempty"` + VideoResolutionConstraints *uint32 `protobuf:"varint,3,opt,name=VideoResolutionConstraints" json:"VideoResolutionConstraints,omitempty"` + MaxHdcpVersion *ClientIdentification_ClientCapabilities_HdcpVersion `protobuf:"varint,4,opt,name=MaxHdcpVersion,enum=ClientIdentification_ClientCapabilities_HdcpVersion" json:"MaxHdcpVersion,omitempty"` + OemCryptoApiVersion *uint32 `protobuf:"varint,5,opt,name=OemCryptoApiVersion" json:"OemCryptoApiVersion,omitempty"` +} + +func (x *ClientIdentification_ClientCapabilities) Reset() { + *x = ClientIdentification_ClientCapabilities{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ClientIdentification_ClientCapabilities) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientIdentification_ClientCapabilities) ProtoMessage() {} + +func (x *ClientIdentification_ClientCapabilities) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[28] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClientIdentification_ClientCapabilities.ProtoReflect.Descriptor instead. +func (*ClientIdentification_ClientCapabilities) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{0, 1} +} + +func (x *ClientIdentification_ClientCapabilities) GetClientToken() uint32 { + if x != nil && x.ClientToken != nil { + return *x.ClientToken + } + return 0 +} + +func (x *ClientIdentification_ClientCapabilities) GetSessionToken() uint32 { + if x != nil && x.SessionToken != nil { + return *x.SessionToken + } + return 0 +} + +func (x *ClientIdentification_ClientCapabilities) GetVideoResolutionConstraints() uint32 { + if x != nil && x.VideoResolutionConstraints != nil { + return *x.VideoResolutionConstraints + } + return 0 +} + +func (x *ClientIdentification_ClientCapabilities) GetMaxHdcpVersion() ClientIdentification_ClientCapabilities_HdcpVersion { + if x != nil && x.MaxHdcpVersion != nil { + return *x.MaxHdcpVersion + } + return ClientIdentification_ClientCapabilities_HDCP_NONE +} + +func (x *ClientIdentification_ClientCapabilities) GetOemCryptoApiVersion() uint32 { + if x != nil && x.OemCryptoApiVersion != nil { + return *x.OemCryptoApiVersion + } + return 0 +} + +type License_Policy struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CanPlay *bool `protobuf:"varint,1,opt,name=CanPlay" json:"CanPlay,omitempty"` // changed from uint32 to bool + CanPersist *bool `protobuf:"varint,2,opt,name=CanPersist" json:"CanPersist,omitempty"` + CanRenew *bool `protobuf:"varint,3,opt,name=CanRenew" json:"CanRenew,omitempty"` + RentalDurationSeconds *uint32 `protobuf:"varint,4,opt,name=RentalDurationSeconds" json:"RentalDurationSeconds,omitempty"` + PlaybackDurationSeconds *uint32 `protobuf:"varint,5,opt,name=PlaybackDurationSeconds" json:"PlaybackDurationSeconds,omitempty"` + LicenseDurationSeconds *uint32 `protobuf:"varint,6,opt,name=LicenseDurationSeconds" json:"LicenseDurationSeconds,omitempty"` + RenewalRecoveryDurationSeconds *uint32 `protobuf:"varint,7,opt,name=RenewalRecoveryDurationSeconds" json:"RenewalRecoveryDurationSeconds,omitempty"` + RenewalServerUrl *string `protobuf:"bytes,8,opt,name=RenewalServerUrl" json:"RenewalServerUrl,omitempty"` + RenewalDelaySeconds *uint32 `protobuf:"varint,9,opt,name=RenewalDelaySeconds" json:"RenewalDelaySeconds,omitempty"` + RenewalRetryIntervalSeconds *uint32 `protobuf:"varint,10,opt,name=RenewalRetryIntervalSeconds" json:"RenewalRetryIntervalSeconds,omitempty"` + RenewWithUsage *bool `protobuf:"varint,11,opt,name=RenewWithUsage" json:"RenewWithUsage,omitempty"` // was uint32 +} + +func (x *License_Policy) Reset() { + *x = License_Policy{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *License_Policy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*License_Policy) ProtoMessage() {} + +func (x *License_Policy) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[29] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use License_Policy.ProtoReflect.Descriptor instead. +func (*License_Policy) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6, 0} +} + +func (x *License_Policy) GetCanPlay() bool { + if x != nil && x.CanPlay != nil { + return *x.CanPlay + } + return false +} + +func (x *License_Policy) GetCanPersist() bool { + if x != nil && x.CanPersist != nil { + return *x.CanPersist + } + return false +} + +func (x *License_Policy) GetCanRenew() bool { + if x != nil && x.CanRenew != nil { + return *x.CanRenew + } + return false +} + +func (x *License_Policy) GetRentalDurationSeconds() uint32 { + if x != nil && x.RentalDurationSeconds != nil { + return *x.RentalDurationSeconds + } + return 0 +} + +func (x *License_Policy) GetPlaybackDurationSeconds() uint32 { + if x != nil && x.PlaybackDurationSeconds != nil { + return *x.PlaybackDurationSeconds + } + return 0 +} + +func (x *License_Policy) GetLicenseDurationSeconds() uint32 { + if x != nil && x.LicenseDurationSeconds != nil { + return *x.LicenseDurationSeconds + } + return 0 +} + +func (x *License_Policy) GetRenewalRecoveryDurationSeconds() uint32 { + if x != nil && x.RenewalRecoveryDurationSeconds != nil { + return *x.RenewalRecoveryDurationSeconds + } + return 0 +} + +func (x *License_Policy) GetRenewalServerUrl() string { + if x != nil && x.RenewalServerUrl != nil { + return *x.RenewalServerUrl + } + return "" +} + +func (x *License_Policy) GetRenewalDelaySeconds() uint32 { + if x != nil && x.RenewalDelaySeconds != nil { + return *x.RenewalDelaySeconds + } + return 0 +} + +func (x *License_Policy) GetRenewalRetryIntervalSeconds() uint32 { + if x != nil && x.RenewalRetryIntervalSeconds != nil { + return *x.RenewalRetryIntervalSeconds + } + return 0 +} + +func (x *License_Policy) GetRenewWithUsage() bool { + if x != nil && x.RenewWithUsage != nil { + return *x.RenewWithUsage + } + return false +} + +type License_KeyContainer struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id []byte `protobuf:"bytes,1,opt,name=Id" json:"Id,omitempty"` + Iv []byte `protobuf:"bytes,2,opt,name=Iv" json:"Iv,omitempty"` + Key []byte `protobuf:"bytes,3,opt,name=Key" json:"Key,omitempty"` + Type *License_KeyContainer_KeyType `protobuf:"varint,4,opt,name=Type,enum=License_KeyContainer_KeyType" json:"Type,omitempty"` + Level *License_KeyContainer_SecurityLevel `protobuf:"varint,5,opt,name=Level,enum=License_KeyContainer_SecurityLevel" json:"Level,omitempty"` + RequiredProtection *License_KeyContainer_OutputProtection `protobuf:"bytes,6,opt,name=RequiredProtection" json:"RequiredProtection,omitempty"` + RequestedProtection *License_KeyContainer_OutputProtection `protobuf:"bytes,7,opt,name=RequestedProtection" json:"RequestedProtection,omitempty"` + XKeyControl *License_KeyContainer_KeyControl `protobuf:"bytes,8,opt,name=_KeyControl,json=KeyControl" json:"_KeyControl,omitempty"` // duped names, etc + XOperatorSessionKeyPermissions *License_KeyContainer_OperatorSessionKeyPermissions `protobuf:"bytes,9,opt,name=_OperatorSessionKeyPermissions,json=OperatorSessionKeyPermissions" json:"_OperatorSessionKeyPermissions,omitempty"` // duped names, etc + VideoResolutionConstraints []*License_KeyContainer_VideoResolutionConstraint `protobuf:"bytes,10,rep,name=VideoResolutionConstraints" json:"VideoResolutionConstraints,omitempty"` +} + +func (x *License_KeyContainer) Reset() { + *x = License_KeyContainer{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *License_KeyContainer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*License_KeyContainer) ProtoMessage() {} + +func (x *License_KeyContainer) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[30] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use License_KeyContainer.ProtoReflect.Descriptor instead. +func (*License_KeyContainer) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6, 1} +} + +func (x *License_KeyContainer) GetId() []byte { + if x != nil { + return x.Id + } + return nil +} + +func (x *License_KeyContainer) GetIv() []byte { + if x != nil { + return x.Iv + } + return nil +} + +func (x *License_KeyContainer) GetKey() []byte { + if x != nil { + return x.Key + } + return nil +} + +func (x *License_KeyContainer) GetType() License_KeyContainer_KeyType { + if x != nil && x.Type != nil { + return *x.Type + } + return License_KeyContainer_SIGNING +} + +func (x *License_KeyContainer) GetLevel() License_KeyContainer_SecurityLevel { + if x != nil && x.Level != nil { + return *x.Level + } + return License_KeyContainer_SW_SECURE_CRYPTO +} + +func (x *License_KeyContainer) GetRequiredProtection() *License_KeyContainer_OutputProtection { + if x != nil { + return x.RequiredProtection + } + return nil +} + +func (x *License_KeyContainer) GetRequestedProtection() *License_KeyContainer_OutputProtection { + if x != nil { + return x.RequestedProtection + } + return nil +} + +func (x *License_KeyContainer) GetXKeyControl() *License_KeyContainer_KeyControl { + if x != nil { + return x.XKeyControl + } + return nil +} + +func (x *License_KeyContainer) GetXOperatorSessionKeyPermissions() *License_KeyContainer_OperatorSessionKeyPermissions { + if x != nil { + return x.XOperatorSessionKeyPermissions + } + return nil +} + +func (x *License_KeyContainer) GetVideoResolutionConstraints() []*License_KeyContainer_VideoResolutionConstraint { + if x != nil { + return x.VideoResolutionConstraints + } + return nil +} + +type License_KeyContainer_OutputProtection struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Hdcp *ClientIdentification_ClientCapabilities_HdcpVersion `protobuf:"varint,1,opt,name=Hdcp,enum=ClientIdentification_ClientCapabilities_HdcpVersion" json:"Hdcp,omitempty"` // it's most likely a copy of Hdcp version available here, but compiler optimized it away + CgmsFlags *License_KeyContainer_OutputProtection_CGMS `protobuf:"varint,2,opt,name=CgmsFlags,enum=License_KeyContainer_OutputProtection_CGMS" json:"CgmsFlags,omitempty"` +} + +func (x *License_KeyContainer_OutputProtection) Reset() { + *x = License_KeyContainer_OutputProtection{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *License_KeyContainer_OutputProtection) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*License_KeyContainer_OutputProtection) ProtoMessage() {} + +func (x *License_KeyContainer_OutputProtection) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[31] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use License_KeyContainer_OutputProtection.ProtoReflect.Descriptor instead. +func (*License_KeyContainer_OutputProtection) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6, 1, 0} +} + +func (x *License_KeyContainer_OutputProtection) GetHdcp() ClientIdentification_ClientCapabilities_HdcpVersion { + if x != nil && x.Hdcp != nil { + return *x.Hdcp + } + return ClientIdentification_ClientCapabilities_HDCP_NONE +} + +func (x *License_KeyContainer_OutputProtection) GetCgmsFlags() License_KeyContainer_OutputProtection_CGMS { + if x != nil && x.CgmsFlags != nil { + return *x.CgmsFlags + } + return License_KeyContainer_OutputProtection_COPY_FREE +} + +type License_KeyContainer_KeyControl struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + KeyControlBlock []byte `protobuf:"bytes,1,req,name=KeyControlBlock" json:"KeyControlBlock,omitempty"` // what is this? + Iv []byte `protobuf:"bytes,2,req,name=Iv" json:"Iv,omitempty"` +} + +func (x *License_KeyContainer_KeyControl) Reset() { + *x = License_KeyContainer_KeyControl{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *License_KeyContainer_KeyControl) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*License_KeyContainer_KeyControl) ProtoMessage() {} + +func (x *License_KeyContainer_KeyControl) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[32] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use License_KeyContainer_KeyControl.ProtoReflect.Descriptor instead. +func (*License_KeyContainer_KeyControl) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6, 1, 1} +} + +func (x *License_KeyContainer_KeyControl) GetKeyControlBlock() []byte { + if x != nil { + return x.KeyControlBlock + } + return nil +} + +func (x *License_KeyContainer_KeyControl) GetIv() []byte { + if x != nil { + return x.Iv + } + return nil +} + +type License_KeyContainer_OperatorSessionKeyPermissions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AllowEncrypt *uint32 `protobuf:"varint,1,opt,name=AllowEncrypt" json:"AllowEncrypt,omitempty"` + AllowDecrypt *uint32 `protobuf:"varint,2,opt,name=AllowDecrypt" json:"AllowDecrypt,omitempty"` + AllowSign *uint32 `protobuf:"varint,3,opt,name=AllowSign" json:"AllowSign,omitempty"` + AllowSignatureVerify *uint32 `protobuf:"varint,4,opt,name=AllowSignatureVerify" json:"AllowSignatureVerify,omitempty"` +} + +func (x *License_KeyContainer_OperatorSessionKeyPermissions) Reset() { + *x = License_KeyContainer_OperatorSessionKeyPermissions{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *License_KeyContainer_OperatorSessionKeyPermissions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*License_KeyContainer_OperatorSessionKeyPermissions) ProtoMessage() {} + +func (x *License_KeyContainer_OperatorSessionKeyPermissions) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[33] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use License_KeyContainer_OperatorSessionKeyPermissions.ProtoReflect.Descriptor instead. +func (*License_KeyContainer_OperatorSessionKeyPermissions) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6, 1, 2} +} + +func (x *License_KeyContainer_OperatorSessionKeyPermissions) GetAllowEncrypt() uint32 { + if x != nil && x.AllowEncrypt != nil { + return *x.AllowEncrypt + } + return 0 +} + +func (x *License_KeyContainer_OperatorSessionKeyPermissions) GetAllowDecrypt() uint32 { + if x != nil && x.AllowDecrypt != nil { + return *x.AllowDecrypt + } + return 0 +} + +func (x *License_KeyContainer_OperatorSessionKeyPermissions) GetAllowSign() uint32 { + if x != nil && x.AllowSign != nil { + return *x.AllowSign + } + return 0 +} + +func (x *License_KeyContainer_OperatorSessionKeyPermissions) GetAllowSignatureVerify() uint32 { + if x != nil && x.AllowSignatureVerify != nil { + return *x.AllowSignatureVerify + } + return 0 +} + +type License_KeyContainer_VideoResolutionConstraint struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + MinResolutionPixels *uint32 `protobuf:"varint,1,opt,name=MinResolutionPixels" json:"MinResolutionPixels,omitempty"` + MaxResolutionPixels *uint32 `protobuf:"varint,2,opt,name=MaxResolutionPixels" json:"MaxResolutionPixels,omitempty"` + RequiredProtection *License_KeyContainer_OutputProtection `protobuf:"bytes,3,opt,name=RequiredProtection" json:"RequiredProtection,omitempty"` +} + +func (x *License_KeyContainer_VideoResolutionConstraint) Reset() { + *x = License_KeyContainer_VideoResolutionConstraint{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *License_KeyContainer_VideoResolutionConstraint) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*License_KeyContainer_VideoResolutionConstraint) ProtoMessage() {} + +func (x *License_KeyContainer_VideoResolutionConstraint) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[34] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use License_KeyContainer_VideoResolutionConstraint.ProtoReflect.Descriptor instead. +func (*License_KeyContainer_VideoResolutionConstraint) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{6, 1, 3} +} + +func (x *License_KeyContainer_VideoResolutionConstraint) GetMinResolutionPixels() uint32 { + if x != nil && x.MinResolutionPixels != nil { + return *x.MinResolutionPixels + } + return 0 +} + +func (x *License_KeyContainer_VideoResolutionConstraint) GetMaxResolutionPixels() uint32 { + if x != nil && x.MaxResolutionPixels != nil { + return *x.MaxResolutionPixels + } + return 0 +} + +func (x *License_KeyContainer_VideoResolutionConstraint) GetRequiredProtection() *License_KeyContainer_OutputProtection { + if x != nil { + return x.RequiredProtection + } + return nil +} + +type LicenseRequest_ContentIdentification struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CencId *LicenseRequest_ContentIdentification_CENC `protobuf:"bytes,1,opt,name=CencId" json:"CencId,omitempty"` + WebmId *LicenseRequest_ContentIdentification_WebM `protobuf:"bytes,2,opt,name=WebmId" json:"WebmId,omitempty"` + License *LicenseRequest_ContentIdentification_ExistingLicense `protobuf:"bytes,3,opt,name=License" json:"License,omitempty"` +} + +func (x *LicenseRequest_ContentIdentification) Reset() { + *x = LicenseRequest_ContentIdentification{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequest_ContentIdentification) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequest_ContentIdentification) ProtoMessage() {} + +func (x *LicenseRequest_ContentIdentification) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[35] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequest_ContentIdentification.ProtoReflect.Descriptor instead. +func (*LicenseRequest_ContentIdentification) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{8, 0} +} + +func (x *LicenseRequest_ContentIdentification) GetCencId() *LicenseRequest_ContentIdentification_CENC { + if x != nil { + return x.CencId + } + return nil +} + +func (x *LicenseRequest_ContentIdentification) GetWebmId() *LicenseRequest_ContentIdentification_WebM { + if x != nil { + return x.WebmId + } + return nil +} + +func (x *LicenseRequest_ContentIdentification) GetLicense() *LicenseRequest_ContentIdentification_ExistingLicense { + if x != nil { + return x.License + } + return nil +} + +type LicenseRequest_ContentIdentification_CENC struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + //optional bytes Pssh = 1; // the client's definition is opaque, it doesn't care about the contents, but the PSSH has a clear definition that is understood and requested by the server, thus I'll replace it with: + Pssh *WidevineCencHeader `protobuf:"bytes,1,opt,name=Pssh" json:"Pssh,omitempty"` + LicenseType *LicenseType `protobuf:"varint,2,opt,name=LicenseType,enum=LicenseType" json:"LicenseType,omitempty"` // unfortunately the LicenseType symbols are not present, acceptable value seems to only be 1 (is this persist/don't persist? look into it!) + RequestId []byte `protobuf:"bytes,3,opt,name=RequestId" json:"RequestId,omitempty"` +} + +func (x *LicenseRequest_ContentIdentification_CENC) Reset() { + *x = LicenseRequest_ContentIdentification_CENC{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequest_ContentIdentification_CENC) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequest_ContentIdentification_CENC) ProtoMessage() {} + +func (x *LicenseRequest_ContentIdentification_CENC) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[36] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequest_ContentIdentification_CENC.ProtoReflect.Descriptor instead. +func (*LicenseRequest_ContentIdentification_CENC) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{8, 0, 0} +} + +func (x *LicenseRequest_ContentIdentification_CENC) GetPssh() *WidevineCencHeader { + if x != nil { + return x.Pssh + } + return nil +} + +func (x *LicenseRequest_ContentIdentification_CENC) GetLicenseType() LicenseType { + if x != nil && x.LicenseType != nil { + return *x.LicenseType + } + return LicenseType_ZERO +} + +func (x *LicenseRequest_ContentIdentification_CENC) GetRequestId() []byte { + if x != nil { + return x.RequestId + } + return nil +} + +type LicenseRequest_ContentIdentification_WebM struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Header []byte `protobuf:"bytes,1,opt,name=Header" json:"Header,omitempty"` // identical to CENC, aside from PSSH and the parent field number used + LicenseType *LicenseType `protobuf:"varint,2,opt,name=LicenseType,enum=LicenseType" json:"LicenseType,omitempty"` + RequestId []byte `protobuf:"bytes,3,opt,name=RequestId" json:"RequestId,omitempty"` +} + +func (x *LicenseRequest_ContentIdentification_WebM) Reset() { + *x = LicenseRequest_ContentIdentification_WebM{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequest_ContentIdentification_WebM) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequest_ContentIdentification_WebM) ProtoMessage() {} + +func (x *LicenseRequest_ContentIdentification_WebM) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[37] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequest_ContentIdentification_WebM.ProtoReflect.Descriptor instead. +func (*LicenseRequest_ContentIdentification_WebM) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{8, 0, 1} +} + +func (x *LicenseRequest_ContentIdentification_WebM) GetHeader() []byte { + if x != nil { + return x.Header + } + return nil +} + +func (x *LicenseRequest_ContentIdentification_WebM) GetLicenseType() LicenseType { + if x != nil && x.LicenseType != nil { + return *x.LicenseType + } + return LicenseType_ZERO +} + +func (x *LicenseRequest_ContentIdentification_WebM) GetRequestId() []byte { + if x != nil { + return x.RequestId + } + return nil +} + +type LicenseRequest_ContentIdentification_ExistingLicense struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + LicenseId *LicenseIdentification `protobuf:"bytes,1,opt,name=LicenseId" json:"LicenseId,omitempty"` + SecondsSinceStarted *uint32 `protobuf:"varint,2,opt,name=SecondsSinceStarted" json:"SecondsSinceStarted,omitempty"` + SecondsSinceLastPlayed *uint32 `protobuf:"varint,3,opt,name=SecondsSinceLastPlayed" json:"SecondsSinceLastPlayed,omitempty"` + SessionUsageTableEntry []byte `protobuf:"bytes,4,opt,name=SessionUsageTableEntry" json:"SessionUsageTableEntry,omitempty"` // interesting! try to figure out the connection between the usage table blob and KCB! +} + +func (x *LicenseRequest_ContentIdentification_ExistingLicense) Reset() { + *x = LicenseRequest_ContentIdentification_ExistingLicense{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequest_ContentIdentification_ExistingLicense) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequest_ContentIdentification_ExistingLicense) ProtoMessage() {} + +func (x *LicenseRequest_ContentIdentification_ExistingLicense) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[38] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequest_ContentIdentification_ExistingLicense.ProtoReflect.Descriptor instead. +func (*LicenseRequest_ContentIdentification_ExistingLicense) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{8, 0, 2} +} + +func (x *LicenseRequest_ContentIdentification_ExistingLicense) GetLicenseId() *LicenseIdentification { + if x != nil { + return x.LicenseId + } + return nil +} + +func (x *LicenseRequest_ContentIdentification_ExistingLicense) GetSecondsSinceStarted() uint32 { + if x != nil && x.SecondsSinceStarted != nil { + return *x.SecondsSinceStarted + } + return 0 +} + +func (x *LicenseRequest_ContentIdentification_ExistingLicense) GetSecondsSinceLastPlayed() uint32 { + if x != nil && x.SecondsSinceLastPlayed != nil { + return *x.SecondsSinceLastPlayed + } + return 0 +} + +func (x *LicenseRequest_ContentIdentification_ExistingLicense) GetSessionUsageTableEntry() []byte { + if x != nil { + return x.SessionUsageTableEntry + } + return nil +} + +type LicenseRequestRaw_ContentIdentification struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CencId *LicenseRequestRaw_ContentIdentification_CENC `protobuf:"bytes,1,opt,name=CencId" json:"CencId,omitempty"` + WebmId *LicenseRequestRaw_ContentIdentification_WebM `protobuf:"bytes,2,opt,name=WebmId" json:"WebmId,omitempty"` + License *LicenseRequestRaw_ContentIdentification_ExistingLicense `protobuf:"bytes,3,opt,name=License" json:"License,omitempty"` +} + +func (x *LicenseRequestRaw_ContentIdentification) Reset() { + *x = LicenseRequestRaw_ContentIdentification{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequestRaw_ContentIdentification) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequestRaw_ContentIdentification) ProtoMessage() {} + +func (x *LicenseRequestRaw_ContentIdentification) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[39] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequestRaw_ContentIdentification.ProtoReflect.Descriptor instead. +func (*LicenseRequestRaw_ContentIdentification) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{9, 0} +} + +func (x *LicenseRequestRaw_ContentIdentification) GetCencId() *LicenseRequestRaw_ContentIdentification_CENC { + if x != nil { + return x.CencId + } + return nil +} + +func (x *LicenseRequestRaw_ContentIdentification) GetWebmId() *LicenseRequestRaw_ContentIdentification_WebM { + if x != nil { + return x.WebmId + } + return nil +} + +func (x *LicenseRequestRaw_ContentIdentification) GetLicense() *LicenseRequestRaw_ContentIdentification_ExistingLicense { + if x != nil { + return x.License + } + return nil +} + +type LicenseRequestRaw_ContentIdentification_CENC struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pssh []byte `protobuf:"bytes,1,opt,name=Pssh" json:"Pssh,omitempty"` // the client's definition is opaque, it doesn't care about the contents, but the PSSH has a clear definition that is understood and requested by the server, thus I'll replace it with: + //optional WidevineCencHeader Pssh = 1; + LicenseType *LicenseType `protobuf:"varint,2,opt,name=LicenseType,enum=LicenseType" json:"LicenseType,omitempty"` // unfortunately the LicenseType symbols are not present, acceptable value seems to only be 1 (is this persist/don't persist? look into it!) + RequestId []byte `protobuf:"bytes,3,opt,name=RequestId" json:"RequestId,omitempty"` +} + +func (x *LicenseRequestRaw_ContentIdentification_CENC) Reset() { + *x = LicenseRequestRaw_ContentIdentification_CENC{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequestRaw_ContentIdentification_CENC) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequestRaw_ContentIdentification_CENC) ProtoMessage() {} + +func (x *LicenseRequestRaw_ContentIdentification_CENC) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[40] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequestRaw_ContentIdentification_CENC.ProtoReflect.Descriptor instead. +func (*LicenseRequestRaw_ContentIdentification_CENC) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{9, 0, 0} +} + +func (x *LicenseRequestRaw_ContentIdentification_CENC) GetPssh() []byte { + if x != nil { + return x.Pssh + } + return nil +} + +func (x *LicenseRequestRaw_ContentIdentification_CENC) GetLicenseType() LicenseType { + if x != nil && x.LicenseType != nil { + return *x.LicenseType + } + return LicenseType_ZERO +} + +func (x *LicenseRequestRaw_ContentIdentification_CENC) GetRequestId() []byte { + if x != nil { + return x.RequestId + } + return nil +} + +type LicenseRequestRaw_ContentIdentification_WebM struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Header []byte `protobuf:"bytes,1,opt,name=Header" json:"Header,omitempty"` // identical to CENC, aside from PSSH and the parent field number used + LicenseType *LicenseType `protobuf:"varint,2,opt,name=LicenseType,enum=LicenseType" json:"LicenseType,omitempty"` + RequestId []byte `protobuf:"bytes,3,opt,name=RequestId" json:"RequestId,omitempty"` +} + +func (x *LicenseRequestRaw_ContentIdentification_WebM) Reset() { + *x = LicenseRequestRaw_ContentIdentification_WebM{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequestRaw_ContentIdentification_WebM) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequestRaw_ContentIdentification_WebM) ProtoMessage() {} + +func (x *LicenseRequestRaw_ContentIdentification_WebM) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[41] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequestRaw_ContentIdentification_WebM.ProtoReflect.Descriptor instead. +func (*LicenseRequestRaw_ContentIdentification_WebM) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{9, 0, 1} +} + +func (x *LicenseRequestRaw_ContentIdentification_WebM) GetHeader() []byte { + if x != nil { + return x.Header + } + return nil +} + +func (x *LicenseRequestRaw_ContentIdentification_WebM) GetLicenseType() LicenseType { + if x != nil && x.LicenseType != nil { + return *x.LicenseType + } + return LicenseType_ZERO +} + +func (x *LicenseRequestRaw_ContentIdentification_WebM) GetRequestId() []byte { + if x != nil { + return x.RequestId + } + return nil +} + +type LicenseRequestRaw_ContentIdentification_ExistingLicense struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + LicenseId *LicenseIdentification `protobuf:"bytes,1,opt,name=LicenseId" json:"LicenseId,omitempty"` + SecondsSinceStarted *uint32 `protobuf:"varint,2,opt,name=SecondsSinceStarted" json:"SecondsSinceStarted,omitempty"` + SecondsSinceLastPlayed *uint32 `protobuf:"varint,3,opt,name=SecondsSinceLastPlayed" json:"SecondsSinceLastPlayed,omitempty"` + SessionUsageTableEntry []byte `protobuf:"bytes,4,opt,name=SessionUsageTableEntry" json:"SessionUsageTableEntry,omitempty"` // interesting! try to figure out the connection between the usage table blob and KCB! +} + +func (x *LicenseRequestRaw_ContentIdentification_ExistingLicense) Reset() { + *x = LicenseRequestRaw_ContentIdentification_ExistingLicense{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *LicenseRequestRaw_ContentIdentification_ExistingLicense) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LicenseRequestRaw_ContentIdentification_ExistingLicense) ProtoMessage() {} + +func (x *LicenseRequestRaw_ContentIdentification_ExistingLicense) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[42] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LicenseRequestRaw_ContentIdentification_ExistingLicense.ProtoReflect.Descriptor instead. +func (*LicenseRequestRaw_ContentIdentification_ExistingLicense) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{9, 0, 2} +} + +func (x *LicenseRequestRaw_ContentIdentification_ExistingLicense) GetLicenseId() *LicenseIdentification { + if x != nil { + return x.LicenseId + } + return nil +} + +func (x *LicenseRequestRaw_ContentIdentification_ExistingLicense) GetSecondsSinceStarted() uint32 { + if x != nil && x.SecondsSinceStarted != nil { + return *x.SecondsSinceStarted + } + return 0 +} + +func (x *LicenseRequestRaw_ContentIdentification_ExistingLicense) GetSecondsSinceLastPlayed() uint32 { + if x != nil && x.SecondsSinceLastPlayed != nil { + return *x.SecondsSinceLastPlayed + } + return 0 +} + +func (x *LicenseRequestRaw_ContentIdentification_ExistingLicense) GetSessionUsageTableEntry() []byte { + if x != nil { + return x.SessionUsageTableEntry + } + return nil +} + +type FileHashes_Signature struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Filename *string `protobuf:"bytes,1,opt,name=filename" json:"filename,omitempty"` + TestSigning *bool `protobuf:"varint,2,opt,name=test_signing,json=testSigning" json:"test_signing,omitempty"` //0 - release, 1 - testing + SHA512Hash []byte `protobuf:"bytes,3,opt,name=SHA512Hash" json:"SHA512Hash,omitempty"` + MainExe *bool `protobuf:"varint,4,opt,name=main_exe,json=mainExe" json:"main_exe,omitempty"` //0 for dlls, 1 for exe, this is field 3 in file + Signature []byte `protobuf:"bytes,5,opt,name=signature" json:"signature,omitempty"` +} + +func (x *FileHashes_Signature) Reset() { + *x = FileHashes_Signature{} + if protoimpl.UnsafeEnabled { + mi := &file_wv_proto2_proto_msgTypes[43] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FileHashes_Signature) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileHashes_Signature) ProtoMessage() {} + +func (x *FileHashes_Signature) ProtoReflect() protoreflect.Message { + mi := &file_wv_proto2_proto_msgTypes[43] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FileHashes_Signature.ProtoReflect.Descriptor instead. +func (*FileHashes_Signature) Descriptor() ([]byte, []int) { + return file_wv_proto2_proto_rawDescGZIP(), []int{26, 0} +} + +func (x *FileHashes_Signature) GetFilename() string { + if x != nil && x.Filename != nil { + return *x.Filename + } + return "" +} + +func (x *FileHashes_Signature) GetTestSigning() bool { + if x != nil && x.TestSigning != nil { + return *x.TestSigning + } + return false +} + +func (x *FileHashes_Signature) GetSHA512Hash() []byte { + if x != nil { + return x.SHA512Hash + } + return nil +} + +func (x *FileHashes_Signature) GetMainExe() bool { + if x != nil && x.MainExe != nil { + return *x.MainExe + } + return false +} + +func (x *FileHashes_Signature) GetSignature() []byte { + if x != nil { + return x.Signature + } + return nil +} + +var File_wv_proto2_proto protoreflect.FileDescriptor + +var file_wv_proto2_proto_rawDesc = []byte{ + 0x0a, 0x0f, 0x77, 0x76, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0xae, 0x07, 0x0a, 0x14, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x0a, 0x04, 0x54, 0x79, + 0x70, 0x65, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, + 0x2e, 0x0a, 0x05, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, + 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, + 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x05, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, + 0x3f, 0x0a, 0x0a, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4e, 0x61, 0x6d, 0x65, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x52, 0x0a, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x30, 0x0a, 0x13, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x69, 0x65, + 0x6e, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x13, 0x50, + 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x12, 0x26, 0x0a, 0x0e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x4c, 0x69, 0x63, 0x65, + 0x6e, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x12, 0x59, 0x0a, 0x13, 0x5f, 0x43, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, + 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, + 0x73, 0x52, 0x12, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, + 0x69, 0x74, 0x69, 0x65, 0x73, 0x12, 0x2c, 0x0a, 0x0b, 0x5f, 0x46, 0x69, 0x6c, 0x65, 0x48, 0x61, + 0x73, 0x68, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0b, 0x2e, 0x46, 0x69, 0x6c, + 0x65, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x52, 0x0a, 0x46, 0x69, 0x6c, 0x65, 0x48, 0x61, 0x73, + 0x68, 0x65, 0x73, 0x1a, 0x35, 0x0a, 0x09, 0x4e, 0x61, 0x6d, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x04, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x02, 0x28, 0x09, 0x52, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x1a, 0x80, 0x03, 0x0a, 0x12, 0x43, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, + 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x54, 0x6f, + 0x6b, 0x65, 0x6e, 0x12, 0x22, 0x0a, 0x0c, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, + 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x53, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x3e, 0x0a, 0x1a, 0x56, 0x69, 0x64, 0x65, 0x6f, + 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, + 0x61, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x1a, 0x56, 0x69, 0x64, + 0x65, 0x6f, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x73, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x5c, 0x0a, 0x0e, 0x4d, 0x61, 0x78, 0x48, 0x64, + 0x63, 0x70, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x34, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x70, + 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x48, 0x64, 0x63, 0x70, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0e, 0x4d, 0x61, 0x78, 0x48, 0x64, 0x63, 0x70, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x13, 0x4f, 0x65, 0x6d, 0x43, 0x72, 0x79, 0x70, + 0x74, 0x6f, 0x41, 0x70, 0x69, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x13, 0x4f, 0x65, 0x6d, 0x43, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x41, 0x70, 0x69, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x54, 0x0a, 0x0b, 0x48, 0x64, 0x63, 0x70, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0d, 0x0a, 0x09, 0x48, 0x44, 0x43, 0x50, 0x5f, 0x4e, + 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x48, 0x44, 0x43, 0x50, 0x5f, 0x56, 0x31, + 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x48, 0x44, 0x43, 0x50, 0x5f, 0x56, 0x32, 0x10, 0x02, 0x12, + 0x0d, 0x0a, 0x09, 0x48, 0x44, 0x43, 0x50, 0x5f, 0x56, 0x32, 0x5f, 0x31, 0x10, 0x03, 0x12, 0x0d, + 0x0a, 0x09, 0x48, 0x44, 0x43, 0x50, 0x5f, 0x56, 0x32, 0x5f, 0x32, 0x10, 0x04, 0x22, 0x53, 0x0a, + 0x09, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x4b, 0x45, + 0x59, 0x42, 0x4f, 0x58, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x44, 0x45, 0x56, 0x49, 0x43, 0x45, + 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x10, 0x01, 0x12, 0x22, + 0x0a, 0x1e, 0x52, 0x45, 0x4d, 0x4f, 0x54, 0x45, 0x5f, 0x41, 0x54, 0x54, 0x45, 0x53, 0x54, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, + 0x10, 0x02, 0x22, 0xfa, 0x02, 0x0a, 0x11, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, + 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x12, 0x36, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, + 0x18, 0x01, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, + 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x2e, 0x43, 0x65, 0x72, 0x74, 0x69, + 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x22, 0x0a, 0x0c, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x54, 0x69, 0x6d, 0x65, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x53, + 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x4b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x50, 0x75, 0x62, 0x6c, 0x69, + 0x63, 0x4b, 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x64, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x64, + 0x12, 0x32, 0x0a, 0x14, 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, + 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x14, + 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, + 0x61, 0x74, 0x65, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x49, + 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x49, 0x64, 0x22, 0x4b, 0x0a, 0x0f, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x52, 0x4f, 0x4f, 0x54, 0x10, 0x00, 0x12, + 0x10, 0x0a, 0x0c, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x4d, 0x45, 0x44, 0x49, 0x41, 0x54, 0x45, 0x10, + 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x45, 0x56, 0x49, 0x43, 0x45, + 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x10, 0x03, 0x22, + 0xe6, 0x01, 0x0a, 0x17, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x53, + 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x0c, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, + 0x42, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x2a, 0x2e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x36, 0x0a, 0x0a, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, + 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x0a, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x2b, 0x0a, 0x11, 0x43, + 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x09, 0x0a, 0x05, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x52, + 0x45, 0x56, 0x4f, 0x4b, 0x45, 0x44, 0x10, 0x01, 0x22, 0x97, 0x01, 0x0a, 0x1b, 0x44, 0x65, 0x76, + 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, + 0x69, 0x6d, 0x65, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x46, 0x0a, 0x11, 0x43, 0x65, + 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x65, + 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x11, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x22, 0x97, 0x02, 0x0a, 0x1d, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x49, + 0x64, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x09, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, + 0x49, 0x64, 0x12, 0x46, 0x0a, 0x1e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, + 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x1e, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x65, + 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x2c, 0x0a, 0x11, 0x45, 0x6e, + 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x18, + 0x03, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x11, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x30, 0x0a, 0x13, 0x45, 0x6e, 0x63, 0x72, + 0x79, 0x70, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x49, 0x76, 0x18, + 0x04, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x13, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x49, 0x76, 0x12, 0x30, 0x0a, 0x13, 0x45, 0x6e, + 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x76, 0x61, 0x63, 0x79, 0x4b, 0x65, + 0x79, 0x18, 0x05, 0x20, 0x02, 0x28, 0x0c, 0x52, 0x13, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, + 0x65, 0x64, 0x50, 0x72, 0x69, 0x76, 0x61, 0x63, 0x79, 0x4b, 0x65, 0x79, 0x22, 0xe3, 0x01, 0x0a, + 0x15, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x50, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, 0x49, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x50, 0x75, 0x72, 0x63, 0x68, 0x61, 0x73, 0x65, + 0x49, 0x64, 0x12, 0x20, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x0c, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x32, + 0x0a, 0x14, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x14, 0x50, 0x72, + 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, + 0x65, 0x6e, 0x22, 0x8d, 0x13, 0x0a, 0x07, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x12, 0x26, + 0x0a, 0x02, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x4c, 0x69, 0x63, + 0x65, 0x6e, 0x73, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x02, 0x49, 0x64, 0x12, 0x28, 0x0a, 0x07, 0x5f, 0x50, 0x6f, 0x6c, 0x69, 0x63, + 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, + 0x65, 0x2e, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x52, 0x06, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x12, 0x27, 0x0a, 0x03, 0x4b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x65, 0x72, 0x52, 0x03, 0x4b, 0x65, 0x79, 0x12, 0x2a, 0x0a, 0x10, 0x4c, 0x69, 0x63, + 0x65, 0x6e, 0x73, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x10, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x53, 0x74, 0x61, 0x72, + 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3c, 0x0a, 0x19, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, + 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x19, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, + 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x56, 0x65, 0x72, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x12, 0x30, 0x0a, 0x13, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x13, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x2a, 0x0a, 0x10, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x10, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x6d, + 0x65, 0x1a, 0x96, 0x04, 0x0a, 0x06, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, 0x18, 0x0a, 0x07, + 0x43, 0x61, 0x6e, 0x50, 0x6c, 0x61, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x43, + 0x61, 0x6e, 0x50, 0x6c, 0x61, 0x79, 0x12, 0x1e, 0x0a, 0x0a, 0x43, 0x61, 0x6e, 0x50, 0x65, 0x72, + 0x73, 0x69, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x43, 0x61, 0x6e, 0x50, + 0x65, 0x72, 0x73, 0x69, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x43, 0x61, 0x6e, 0x52, 0x65, 0x6e, + 0x65, 0x77, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x43, 0x61, 0x6e, 0x52, 0x65, 0x6e, + 0x65, 0x77, 0x12, 0x34, 0x0a, 0x15, 0x52, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x44, 0x75, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x15, 0x52, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x38, 0x0a, 0x17, 0x50, 0x6c, 0x61, 0x79, + 0x62, 0x61, 0x63, 0x6b, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x17, 0x50, 0x6c, 0x61, 0x79, 0x62, + 0x61, 0x63, 0x6b, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, + 0x64, 0x73, 0x12, 0x36, 0x0a, 0x16, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x44, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x16, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x44, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x46, 0x0a, 0x1e, 0x52, 0x65, + 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x79, 0x44, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x1e, 0x52, 0x65, 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x63, 0x6f, 0x76, + 0x65, 0x72, 0x79, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, + 0x64, 0x73, 0x12, 0x2a, 0x0a, 0x10, 0x52, 0x65, 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x53, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x55, 0x72, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x52, 0x65, + 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x55, 0x72, 0x6c, 0x12, 0x30, + 0x0a, 0x13, 0x52, 0x65, 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x53, 0x65, + 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x52, 0x65, 0x6e, + 0x65, 0x77, 0x61, 0x6c, 0x44, 0x65, 0x6c, 0x61, 0x79, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, + 0x12, 0x40, 0x0a, 0x1b, 0x52, 0x65, 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x52, 0x65, 0x74, 0x72, 0x79, + 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x1b, 0x52, 0x65, 0x6e, 0x65, 0x77, 0x61, 0x6c, 0x52, 0x65, + 0x74, 0x72, 0x79, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x53, 0x65, 0x63, 0x6f, 0x6e, + 0x64, 0x73, 0x12, 0x26, 0x0a, 0x0e, 0x52, 0x65, 0x6e, 0x65, 0x77, 0x57, 0x69, 0x74, 0x68, 0x55, + 0x73, 0x61, 0x67, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x52, 0x65, 0x6e, 0x65, + 0x77, 0x57, 0x69, 0x74, 0x68, 0x55, 0x73, 0x61, 0x67, 0x65, 0x1a, 0xa5, 0x0c, 0x0a, 0x0c, 0x4b, + 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x49, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x49, + 0x76, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x49, 0x76, 0x12, 0x10, 0x0a, 0x03, 0x4b, + 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x4b, 0x65, 0x79, 0x12, 0x31, 0x0a, + 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x4c, 0x69, + 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, + 0x65, 0x72, 0x2e, 0x4b, 0x65, 0x79, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x39, 0x0a, 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x23, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4c, + 0x65, 0x76, 0x65, 0x6c, 0x52, 0x05, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x56, 0x0a, 0x12, 0x52, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, + 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x4f, + 0x75, 0x74, 0x70, 0x75, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x12, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x58, 0x0a, 0x13, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x26, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x50, 0x72, + 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, + 0x0b, 0x5f, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x4b, 0x65, 0x79, + 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x52, 0x0a, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, + 0x12, 0x7a, 0x0a, 0x1e, 0x5f, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, + 0x65, 0x79, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x1d, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, + 0x79, 0x50, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x6f, 0x0a, 0x1a, + 0x56, 0x69, 0x64, 0x65, 0x6f, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x43, + 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x2f, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, + 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x56, 0x69, 0x64, 0x65, 0x6f, 0x52, 0x65, 0x73, + 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, + 0x74, 0x52, 0x1a, 0x56, 0x69, 0x64, 0x65, 0x6f, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, + 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x1a, 0xec, 0x01, + 0x0a, 0x10, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x48, 0x0a, 0x04, 0x48, 0x64, 0x63, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x34, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, + 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x2e, 0x48, 0x64, 0x63, 0x70, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x04, 0x48, 0x64, 0x63, 0x70, 0x12, 0x49, 0x0a, 0x09, + 0x43, 0x67, 0x6d, 0x73, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x2b, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, + 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x50, 0x72, 0x6f, + 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x47, 0x4d, 0x53, 0x52, 0x09, 0x43, 0x67, + 0x6d, 0x73, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x22, 0x43, 0x0a, 0x04, 0x43, 0x47, 0x4d, 0x53, 0x12, + 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x50, 0x59, 0x5f, 0x46, 0x52, 0x45, 0x45, 0x10, 0x00, 0x12, 0x0d, + 0x0a, 0x09, 0x43, 0x4f, 0x50, 0x59, 0x5f, 0x4f, 0x4e, 0x43, 0x45, 0x10, 0x02, 0x12, 0x0e, 0x0a, + 0x0a, 0x43, 0x4f, 0x50, 0x59, 0x5f, 0x4e, 0x45, 0x56, 0x45, 0x52, 0x10, 0x03, 0x12, 0x0d, 0x0a, + 0x09, 0x43, 0x47, 0x4d, 0x53, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x2a, 0x1a, 0x46, 0x0a, 0x0a, + 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x12, 0x28, 0x0a, 0x0f, 0x4b, 0x65, + 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, + 0x02, 0x28, 0x0c, 0x52, 0x0f, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x42, + 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x76, 0x18, 0x02, 0x20, 0x02, 0x28, 0x0c, + 0x52, 0x02, 0x49, 0x76, 0x1a, 0xb9, 0x01, 0x0a, 0x1d, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, + 0x72, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x50, 0x65, 0x72, 0x6d, 0x69, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x45, + 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x41, 0x6c, + 0x6c, 0x6f, 0x77, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x12, 0x22, 0x0a, 0x0c, 0x41, 0x6c, + 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x0c, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, 0x12, 0x1c, + 0x0a, 0x09, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x69, 0x67, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x09, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x69, 0x67, 0x6e, 0x12, 0x32, 0x0a, 0x14, + 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x56, 0x65, + 0x72, 0x69, 0x66, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x14, 0x41, 0x6c, 0x6c, 0x6f, + 0x77, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, + 0x1a, 0xd7, 0x01, 0x0a, 0x19, 0x56, 0x69, 0x64, 0x65, 0x6f, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, + 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x12, 0x30, + 0x0a, 0x13, 0x4d, 0x69, 0x6e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, + 0x69, 0x78, 0x65, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x4d, 0x69, 0x6e, + 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x69, 0x78, 0x65, 0x6c, 0x73, + 0x12, 0x30, 0x0a, 0x13, 0x4d, 0x61, 0x78, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x50, 0x69, 0x78, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x4d, + 0x61, 0x78, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x50, 0x69, 0x78, 0x65, + 0x6c, 0x73, 0x12, 0x56, 0x0a, 0x12, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x50, 0x72, + 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, + 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x2e, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x2e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x50, 0x72, 0x6f, 0x74, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x12, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x4a, 0x0a, 0x07, 0x4b, 0x65, + 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x49, 0x47, 0x4e, 0x49, 0x4e, 0x47, + 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x43, 0x4f, 0x4e, 0x54, 0x45, 0x4e, 0x54, 0x10, 0x02, 0x12, + 0x0f, 0x0a, 0x0b, 0x4b, 0x45, 0x59, 0x5f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x4f, 0x4c, 0x10, 0x03, + 0x12, 0x14, 0x0a, 0x10, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x53, 0x45, 0x53, + 0x53, 0x49, 0x4f, 0x4e, 0x10, 0x04, 0x22, 0x7a, 0x0a, 0x0d, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, + 0x74, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x14, 0x0a, 0x10, 0x53, 0x57, 0x5f, 0x53, 0x45, + 0x43, 0x55, 0x52, 0x45, 0x5f, 0x43, 0x52, 0x59, 0x50, 0x54, 0x4f, 0x10, 0x01, 0x12, 0x14, 0x0a, + 0x10, 0x53, 0x57, 0x5f, 0x53, 0x45, 0x43, 0x55, 0x52, 0x45, 0x5f, 0x44, 0x45, 0x43, 0x4f, 0x44, + 0x45, 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x48, 0x57, 0x5f, 0x53, 0x45, 0x43, 0x55, 0x52, 0x45, + 0x5f, 0x43, 0x52, 0x59, 0x50, 0x54, 0x4f, 0x10, 0x03, 0x12, 0x14, 0x0a, 0x10, 0x48, 0x57, 0x5f, + 0x53, 0x45, 0x43, 0x55, 0x52, 0x45, 0x5f, 0x44, 0x45, 0x43, 0x4f, 0x44, 0x45, 0x10, 0x04, 0x12, + 0x11, 0x0a, 0x0d, 0x48, 0x57, 0x5f, 0x53, 0x45, 0x43, 0x55, 0x52, 0x45, 0x5f, 0x41, 0x4c, 0x4c, + 0x10, 0x05, 0x22, 0xa3, 0x01, 0x0a, 0x0c, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x12, 0x31, 0x0a, 0x09, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x64, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x09, 0x45, 0x72, 0x72, + 0x6f, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x22, 0x60, 0x0a, 0x05, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, + 0x1e, 0x0a, 0x1a, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x44, 0x45, 0x56, 0x49, 0x43, + 0x45, 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x10, 0x01, 0x12, + 0x1e, 0x0a, 0x1a, 0x52, 0x45, 0x56, 0x4f, 0x4b, 0x45, 0x44, 0x5f, 0x44, 0x45, 0x56, 0x49, 0x43, + 0x45, 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x10, 0x02, 0x12, + 0x17, 0x0a, 0x13, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, 0x55, 0x4e, 0x41, 0x56, 0x41, + 0x49, 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x22, 0xcb, 0x09, 0x0a, 0x0e, 0x4c, 0x69, 0x63, + 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x31, 0x0a, 0x08, 0x43, + 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x43, + 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x25, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x49, 0x64, 0x12, 0x2f, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x1b, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3c, 0x0a, 0x19, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, + 0x74, 0x72, 0x6f, 0x6c, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, + 0x74, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x19, 0x4b, 0x65, 0x79, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, + 0x61, 0x74, 0x65, 0x64, 0x12, 0x3a, 0x0a, 0x0f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, + 0x0f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x28, 0x0a, 0x0f, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4e, 0x6f, + 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0f, 0x4b, 0x65, 0x79, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x4c, 0x0a, 0x11, 0x45, 0x6e, + 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, + 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x1a, 0xc9, 0x05, 0x0a, 0x15, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x42, 0x0a, 0x06, 0x43, 0x65, 0x6e, 0x63, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x45, 0x4e, 0x43, 0x52, 0x06, + 0x43, 0x65, 0x6e, 0x63, 0x49, 0x64, 0x12, 0x42, 0x0a, 0x06, 0x57, 0x65, 0x62, 0x6d, 0x49, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, + 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x57, 0x65, + 0x62, 0x4d, 0x52, 0x06, 0x57, 0x65, 0x62, 0x6d, 0x49, 0x64, 0x12, 0x4f, 0x0a, 0x07, 0x4c, 0x69, + 0x63, 0x65, 0x6e, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x4c, 0x69, + 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x45, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x52, 0x07, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x1a, 0x7d, 0x0a, 0x04, 0x43, + 0x45, 0x4e, 0x43, 0x12, 0x27, 0x0a, 0x04, 0x50, 0x73, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x13, 0x2e, 0x57, 0x69, 0x64, 0x65, 0x76, 0x69, 0x6e, 0x65, 0x43, 0x65, 0x6e, 0x63, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x04, 0x50, 0x73, 0x73, 0x68, 0x12, 0x2e, 0x0a, 0x0b, + 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x0c, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x0b, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x09, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x1a, 0x6c, 0x0a, 0x04, 0x57, 0x65, + 0x62, 0x4d, 0x12, 0x16, 0x0a, 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x0b, 0x4c, 0x69, + 0x63, 0x65, 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x0c, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x4c, + 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x1a, 0xe9, 0x01, 0x0a, 0x0f, 0x45, 0x78, 0x69, + 0x73, 0x74, 0x69, 0x6e, 0x67, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x09, + 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x16, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, + 0x49, 0x64, 0x12, 0x30, 0x0a, 0x13, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x53, 0x69, 0x6e, + 0x63, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x13, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, + 0x72, 0x74, 0x65, 0x64, 0x12, 0x36, 0x0a, 0x16, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x53, + 0x69, 0x6e, 0x63, 0x65, 0x4c, 0x61, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x64, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x16, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x53, 0x69, 0x6e, + 0x63, 0x65, 0x4c, 0x61, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x64, 0x12, 0x36, 0x0a, 0x16, + 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x55, 0x73, 0x61, 0x67, 0x65, 0x54, 0x61, 0x62, 0x6c, + 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x16, 0x53, 0x65, + 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x55, 0x73, 0x61, 0x67, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x22, 0x30, 0x0a, 0x0b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x07, 0x0a, 0x03, 0x4e, 0x45, 0x57, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, + 0x52, 0x45, 0x4e, 0x45, 0x57, 0x41, 0x4c, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x52, 0x45, 0x4c, + 0x45, 0x41, 0x53, 0x45, 0x10, 0x03, 0x22, 0xc8, 0x09, 0x0a, 0x11, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x77, 0x12, 0x31, 0x0a, 0x08, + 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, + 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, + 0x46, 0x0a, 0x09, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x52, 0x61, 0x77, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x77, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x0b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3c, 0x0a, + 0x19, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4e, 0x6f, 0x6e, 0x63, 0x65, + 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x19, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4e, 0x6f, 0x6e, 0x63, + 0x65, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x3a, 0x0a, 0x0f, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x0f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x0a, 0x0f, 0x4b, 0x65, 0x79, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x0f, 0x4b, 0x65, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4e, 0x6f, 0x6e, 0x63, + 0x65, 0x12, 0x4c, 0x0a, 0x11, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x43, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x45, + 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, + 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x45, 0x6e, + 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x1a, + 0xbd, 0x05, 0x0a, 0x15, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x06, 0x43, 0x65, 0x6e, + 0x63, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x4c, 0x69, 0x63, 0x65, + 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x77, 0x2e, 0x43, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x45, 0x4e, 0x43, 0x52, 0x06, 0x43, 0x65, 0x6e, 0x63, 0x49, 0x64, + 0x12, 0x45, 0x0a, 0x06, 0x57, 0x65, 0x62, 0x6d, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x2d, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x52, 0x61, 0x77, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, + 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x57, 0x65, 0x62, 0x4d, 0x52, + 0x06, 0x57, 0x65, 0x62, 0x6d, 0x49, 0x64, 0x12, 0x52, 0x0a, 0x07, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x77, 0x2e, 0x43, 0x6f, 0x6e, + 0x74, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x45, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x52, 0x07, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x1a, 0x68, 0x0a, 0x04, 0x43, + 0x45, 0x4e, 0x43, 0x12, 0x12, 0x0a, 0x04, 0x50, 0x73, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x04, 0x50, 0x73, 0x73, 0x68, 0x12, 0x2e, 0x0a, 0x0b, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0c, 0x2e, 0x4c, + 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x4c, 0x69, 0x63, 0x65, + 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x49, 0x64, 0x1a, 0x6c, 0x0a, 0x04, 0x57, 0x65, 0x62, 0x4d, 0x12, 0x16, 0x0a, + 0x06, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x48, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x0b, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0c, 0x2e, 0x4c, 0x69, 0x63, + 0x65, 0x6e, 0x73, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0b, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x49, 0x64, 0x1a, 0xe9, 0x01, 0x0a, 0x0f, 0x45, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, + 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x09, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x4c, 0x69, 0x63, + 0x65, 0x6e, 0x73, 0x65, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x09, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x49, 0x64, 0x12, 0x30, 0x0a, + 0x13, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, + 0x72, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x53, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x73, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x12, + 0x36, 0x0a, 0x16, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x4c, + 0x61, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x16, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x4c, 0x61, 0x73, + 0x74, 0x50, 0x6c, 0x61, 0x79, 0x65, 0x64, 0x12, 0x36, 0x0a, 0x16, 0x53, 0x65, 0x73, 0x73, 0x69, + 0x6f, 0x6e, 0x55, 0x73, 0x61, 0x67, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, + 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x16, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x55, 0x73, 0x61, 0x67, 0x65, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x22, + 0x30, 0x0a, 0x0b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x07, + 0x0a, 0x03, 0x4e, 0x45, 0x57, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x52, 0x45, 0x4e, 0x45, 0x57, + 0x41, 0x4c, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x52, 0x45, 0x4c, 0x45, 0x41, 0x53, 0x45, 0x10, + 0x03, 0x22, 0xfc, 0x02, 0x0a, 0x15, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x65, + 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1a, 0x0a, 0x08, 0x53, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x08, 0x53, + 0x79, 0x73, 0x74, 0x65, 0x6d, 0x49, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x53, 0x6f, 0x63, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x53, 0x6f, 0x63, 0x12, 0x22, 0x0a, 0x0c, 0x4d, 0x61, 0x6e, + 0x75, 0x66, 0x61, 0x63, 0x74, 0x75, 0x72, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x4d, 0x61, 0x6e, 0x75, 0x66, 0x61, 0x63, 0x74, 0x75, 0x72, 0x65, 0x72, 0x12, 0x14, 0x0a, + 0x05, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x4d, 0x6f, + 0x64, 0x65, 0x6c, 0x12, 0x1e, 0x0a, 0x0a, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, + 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x59, 0x65, 0x61, 0x72, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x4d, 0x6f, 0x64, 0x65, 0x6c, 0x59, 0x65, 0x61, + 0x72, 0x12, 0x4c, 0x0a, 0x0d, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4c, 0x65, 0x76, + 0x65, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x49, 0x6e, 0x66, 0x6f, + 0x2e, 0x57, 0x76, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, + 0x52, 0x0d, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, + 0x1e, 0x0a, 0x0a, 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x22, + 0x4f, 0x0a, 0x0f, 0x57, 0x76, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x4c, 0x65, 0x76, + 0x65, 0x6c, 0x12, 0x15, 0x0a, 0x11, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x55, 0x4e, 0x53, 0x50, + 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x45, 0x56, + 0x45, 0x4c, 0x5f, 0x31, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, + 0x32, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x45, 0x56, 0x45, 0x4c, 0x5f, 0x33, 0x10, 0x03, + 0x22, 0x15, 0x0a, 0x13, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, + 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x15, 0x0a, 0x13, 0x50, 0x72, 0x6f, 0x76, 0x69, + 0x73, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x16, + 0x0a, 0x14, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x87, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x6d, 0x6f, 0x74, + 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x40, 0x0a, 0x0b, + 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x45, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x0b, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x12, 0x12, + 0x0a, 0x04, 0x53, 0x61, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x53, 0x61, + 0x6c, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x22, 0x0d, 0x0a, 0x0b, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x69, 0x74, 0x22, + 0x0e, 0x0a, 0x0c, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x22, + 0x1d, 0x0a, 0x1b, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x4c, 0x69, 0x73, 0x74, 0x22, 0xac, + 0x01, 0x0a, 0x17, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, + 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x12, 0x41, 0x0a, 0x12, 0x5f, 0x44, + 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, + 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x11, 0x44, 0x65, 0x76, 0x69, + 0x63, 0x65, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, + 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x30, 0x0a, 0x06, 0x53, + 0x69, 0x67, 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x53, 0x69, + 0x67, 0x6e, 0x65, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, + 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x06, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x22, 0x1b, 0x0a, + 0x19, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x69, 0x6e, 0x67, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xd0, 0x02, 0x0a, 0x0d, 0x53, + 0x69, 0x67, 0x6e, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x2e, 0x0a, 0x04, + 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x53, 0x69, 0x67, + 0x6e, 0x65, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x03, + 0x4d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x1c, + 0x0a, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1e, 0x0a, 0x0a, + 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x12, 0x40, 0x0a, 0x11, + 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, + 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x52, 0x65, 0x6d, + 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x7d, + 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x13, 0x0a, + 0x0f, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, + 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x10, 0x02, 0x12, + 0x12, 0x0a, 0x0e, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x5f, 0x52, 0x45, 0x53, 0x50, 0x4f, 0x4e, 0x53, + 0x45, 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, 0x43, + 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, + 0x53, 0x54, 0x10, 0x04, 0x12, 0x17, 0x0a, 0x13, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, + 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x10, 0x05, 0x22, 0xd3, 0x03, + 0x0a, 0x12, 0x57, 0x69, 0x64, 0x65, 0x76, 0x69, 0x6e, 0x65, 0x43, 0x65, 0x6e, 0x63, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x12, 0x3b, 0x0a, 0x09, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, + 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x57, 0x69, 0x64, 0x65, 0x76, 0x69, + 0x6e, 0x65, 0x43, 0x65, 0x6e, 0x63, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x41, 0x6c, 0x67, + 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x52, 0x09, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, + 0x6d, 0x12, 0x15, 0x0a, 0x06, 0x6b, 0x65, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0c, 0x52, 0x05, 0x6b, 0x65, 0x79, 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x76, + 0x69, 0x64, 0x65, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x5f, + 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x15, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x5f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x13, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x44, 0x65, 0x70, + 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x6f, 0x6c, 0x69, 0x63, + 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x12, + 0x2e, 0x0a, 0x13, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, + 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x11, 0x63, 0x72, + 0x79, 0x70, 0x74, 0x6f, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, + 0x27, 0x0a, 0x0f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, + 0x64, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x70, 0x72, 0x6f, 0x74, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x5f, + 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x0a, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x50, 0x65, 0x72, 0x69, + 0x6f, 0x64, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0x28, 0x0a, 0x09, 0x41, 0x6c, 0x67, + 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x4e, 0x45, 0x4e, 0x43, 0x52, + 0x59, 0x50, 0x54, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x41, 0x45, 0x53, 0x43, 0x54, + 0x52, 0x10, 0x01, 0x22, 0xef, 0x02, 0x0a, 0x14, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x4c, 0x69, + 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x04, + 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x53, 0x69, 0x67, + 0x6e, 0x65, 0x64, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x0f, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, + 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x4b, 0x65, 0x79, 0x12, 0x40, 0x0a, 0x11, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x74, + 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x12, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, + 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x7d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x13, 0x0a, 0x0f, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, + 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x49, + 0x43, 0x45, 0x4e, 0x53, 0x45, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x52, 0x52, 0x4f, 0x52, + 0x5f, 0x52, 0x45, 0x53, 0x50, 0x4f, 0x4e, 0x53, 0x45, 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x53, + 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, + 0x54, 0x45, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, 0x10, 0x04, 0x12, 0x17, 0x0a, 0x13, + 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, + 0x41, 0x54, 0x45, 0x10, 0x05, 0x22, 0xf8, 0x02, 0x0a, 0x17, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, + 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, + 0x77, 0x12, 0x38, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x24, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x77, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x24, 0x0a, 0x03, 0x4d, + 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x61, 0x77, 0x52, 0x03, 0x4d, 0x73, + 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, + 0x1e, 0x0a, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x12, + 0x40, 0x0a, 0x11, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x52, 0x65, 0x6d, + 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, + 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0x7d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x13, 0x0a, 0x0f, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x5f, 0x52, 0x45, 0x51, 0x55, + 0x45, 0x53, 0x54, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, + 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x5f, 0x52, 0x45, 0x53, 0x50, + 0x4f, 0x4e, 0x53, 0x45, 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, + 0x45, 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x5f, 0x52, 0x45, + 0x51, 0x55, 0x45, 0x53, 0x54, 0x10, 0x04, 0x12, 0x17, 0x0a, 0x13, 0x53, 0x45, 0x52, 0x56, 0x49, + 0x43, 0x45, 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x10, 0x05, + 0x22, 0xda, 0x02, 0x0a, 0x0d, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x4c, 0x69, 0x63, 0x65, 0x6e, + 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x1a, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, + 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x08, 0x2e, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x52, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x1c, + 0x0a, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1e, 0x0a, 0x0a, + 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x12, 0x40, 0x0a, 0x11, + 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, + 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, 0x52, 0x65, 0x6d, + 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x7d, + 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x13, 0x0a, + 0x0f, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, 0x53, 0x54, + 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x10, 0x02, 0x12, + 0x12, 0x0a, 0x0e, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x5f, 0x52, 0x45, 0x53, 0x50, 0x4f, 0x4e, 0x53, + 0x45, 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, 0x43, + 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x45, + 0x53, 0x54, 0x10, 0x04, 0x12, 0x17, 0x0a, 0x13, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x5f, + 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x10, 0x05, 0x22, 0x80, 0x03, + 0x0a, 0x18, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, + 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x12, 0x39, 0x0a, 0x04, 0x54, 0x79, + 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, + 0x64, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, + 0x61, 0x74, 0x65, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2a, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x44, 0x65, 0x76, 0x69, 0x63, + 0x65, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x52, 0x03, 0x4d, 0x73, + 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, + 0x1e, 0x0a, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x12, + 0x40, 0x0a, 0x11, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x52, 0x65, 0x6d, + 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x11, + 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0x7d, 0x0a, 0x0b, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x13, 0x0a, 0x0f, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x5f, 0x52, 0x45, 0x51, 0x55, + 0x45, 0x53, 0x54, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, + 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x5f, 0x52, 0x45, 0x53, 0x50, + 0x4f, 0x4e, 0x53, 0x45, 0x10, 0x03, 0x12, 0x1f, 0x0a, 0x1b, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, + 0x45, 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x5f, 0x52, 0x45, + 0x51, 0x55, 0x45, 0x53, 0x54, 0x10, 0x04, 0x12, 0x17, 0x0a, 0x13, 0x53, 0x45, 0x52, 0x56, 0x49, + 0x43, 0x45, 0x5f, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x10, 0x05, + 0x22, 0x81, 0x02, 0x0a, 0x0a, 0x46, 0x69, 0x6c, 0x65, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x12, + 0x16, 0x0a, 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x12, 0x35, 0x0a, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x46, 0x69, + 0x6c, 0x65, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x52, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x1a, 0xa3, + 0x01, 0x0a, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x1a, 0x0a, 0x08, + 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x65, 0x73, 0x74, + 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, + 0x74, 0x65, 0x73, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x12, 0x1e, 0x0a, 0x0a, 0x53, + 0x48, 0x41, 0x35, 0x31, 0x32, 0x48, 0x61, 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x0a, 0x53, 0x48, 0x41, 0x35, 0x31, 0x32, 0x48, 0x61, 0x73, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x6d, + 0x61, 0x69, 0x6e, 0x5f, 0x65, 0x78, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x6d, + 0x61, 0x69, 0x6e, 0x45, 0x78, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, + 0x75, 0x72, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x69, 0x67, 0x6e, 0x61, + 0x74, 0x75, 0x72, 0x65, 0x2a, 0x31, 0x0a, 0x0b, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x12, 0x0b, 0x0a, + 0x07, 0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x4f, 0x46, + 0x46, 0x4c, 0x49, 0x4e, 0x45, 0x10, 0x02, 0x2a, 0x1e, 0x0a, 0x0f, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x63, 0x6f, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x0b, 0x0a, 0x07, 0x43, 0x55, + 0x52, 0x52, 0x45, 0x4e, 0x54, 0x10, 0x15, 0x42, 0x07, 0x5a, 0x05, 0x2e, 0x3b, 0x67, 0x65, 0x6e, +} + +var ( + file_wv_proto2_proto_rawDescOnce sync.Once + file_wv_proto2_proto_rawDescData = file_wv_proto2_proto_rawDesc +) + +func file_wv_proto2_proto_rawDescGZIP() []byte { + file_wv_proto2_proto_rawDescOnce.Do(func() { + file_wv_proto2_proto_rawDescData = protoimpl.X.CompressGZIP(file_wv_proto2_proto_rawDescData) + }) + return file_wv_proto2_proto_rawDescData +} + +var file_wv_proto2_proto_enumTypes = make([]protoimpl.EnumInfo, 19) +var file_wv_proto2_proto_msgTypes = make([]protoimpl.MessageInfo, 44) +var file_wv_proto2_proto_goTypes = []interface{}{ + (LicenseType)(0), // 0: LicenseType + (ProtocolVersion)(0), // 1: ProtocolVersion + (ClientIdentification_TokenType)(0), // 2: ClientIdentification.TokenType + (ClientIdentification_ClientCapabilities_HdcpVersion)(0), // 3: ClientIdentification.ClientCapabilities.HdcpVersion + (DeviceCertificate_CertificateType)(0), // 4: DeviceCertificate.CertificateType + (DeviceCertificateStatus_CertificateStatus)(0), // 5: DeviceCertificateStatus.CertificateStatus + (License_KeyContainer_KeyType)(0), // 6: License.KeyContainer.KeyType + (License_KeyContainer_SecurityLevel)(0), // 7: License.KeyContainer.SecurityLevel + (License_KeyContainer_OutputProtection_CGMS)(0), // 8: License.KeyContainer.OutputProtection.CGMS + (LicenseError_Error)(0), // 9: LicenseError.Error + (LicenseRequest_RequestType)(0), // 10: LicenseRequest.RequestType + (LicenseRequestRaw_RequestType)(0), // 11: LicenseRequestRaw.RequestType + (ProvisionedDeviceInfo_WvSecurityLevel)(0), // 12: ProvisionedDeviceInfo.WvSecurityLevel + (SignedMessage_MessageType)(0), // 13: SignedMessage.MessageType + (WidevineCencHeader_Algorithm)(0), // 14: WidevineCencHeader.Algorithm + (SignedLicenseRequest_MessageType)(0), // 15: SignedLicenseRequest.MessageType + (SignedLicenseRequestRaw_MessageType)(0), // 16: SignedLicenseRequestRaw.MessageType + (SignedLicense_MessageType)(0), // 17: SignedLicense.MessageType + (SignedServiceCertificate_MessageType)(0), // 18: SignedServiceCertificate.MessageType + (*ClientIdentification)(nil), // 19: ClientIdentification + (*DeviceCertificate)(nil), // 20: DeviceCertificate + (*DeviceCertificateStatus)(nil), // 21: DeviceCertificateStatus + (*DeviceCertificateStatusList)(nil), // 22: DeviceCertificateStatusList + (*EncryptedClientIdentification)(nil), // 23: EncryptedClientIdentification + (*LicenseIdentification)(nil), // 24: LicenseIdentification + (*License)(nil), // 25: License + (*LicenseError)(nil), // 26: LicenseError + (*LicenseRequest)(nil), // 27: LicenseRequest + (*LicenseRequestRaw)(nil), // 28: LicenseRequestRaw + (*ProvisionedDeviceInfo)(nil), // 29: ProvisionedDeviceInfo + (*ProvisioningOptions)(nil), // 30: ProvisioningOptions + (*ProvisioningRequest)(nil), // 31: ProvisioningRequest + (*ProvisioningResponse)(nil), // 32: ProvisioningResponse + (*RemoteAttestation)(nil), // 33: RemoteAttestation + (*SessionInit)(nil), // 34: SessionInit + (*SessionState)(nil), // 35: SessionState + (*SignedCertificateStatusList)(nil), // 36: SignedCertificateStatusList + (*SignedDeviceCertificate)(nil), // 37: SignedDeviceCertificate + (*SignedProvisioningMessage)(nil), // 38: SignedProvisioningMessage + (*SignedMessage)(nil), // 39: SignedMessage + (*WidevineCencHeader)(nil), // 40: WidevineCencHeader + (*SignedLicenseRequest)(nil), // 41: SignedLicenseRequest + (*SignedLicenseRequestRaw)(nil), // 42: SignedLicenseRequestRaw + (*SignedLicense)(nil), // 43: SignedLicense + (*SignedServiceCertificate)(nil), // 44: SignedServiceCertificate + (*FileHashes)(nil), // 45: FileHashes + (*ClientIdentification_NameValue)(nil), // 46: ClientIdentification.NameValue + (*ClientIdentification_ClientCapabilities)(nil), // 47: ClientIdentification.ClientCapabilities + (*License_Policy)(nil), // 48: License.Policy + (*License_KeyContainer)(nil), // 49: License.KeyContainer + (*License_KeyContainer_OutputProtection)(nil), // 50: License.KeyContainer.OutputProtection + (*License_KeyContainer_KeyControl)(nil), // 51: License.KeyContainer.KeyControl + (*License_KeyContainer_OperatorSessionKeyPermissions)(nil), // 52: License.KeyContainer.OperatorSessionKeyPermissions + (*License_KeyContainer_VideoResolutionConstraint)(nil), // 53: License.KeyContainer.VideoResolutionConstraint + (*LicenseRequest_ContentIdentification)(nil), // 54: LicenseRequest.ContentIdentification + (*LicenseRequest_ContentIdentification_CENC)(nil), // 55: LicenseRequest.ContentIdentification.CENC + (*LicenseRequest_ContentIdentification_WebM)(nil), // 56: LicenseRequest.ContentIdentification.WebM + (*LicenseRequest_ContentIdentification_ExistingLicense)(nil), // 57: LicenseRequest.ContentIdentification.ExistingLicense + (*LicenseRequestRaw_ContentIdentification)(nil), // 58: LicenseRequestRaw.ContentIdentification + (*LicenseRequestRaw_ContentIdentification_CENC)(nil), // 59: LicenseRequestRaw.ContentIdentification.CENC + (*LicenseRequestRaw_ContentIdentification_WebM)(nil), // 60: LicenseRequestRaw.ContentIdentification.WebM + (*LicenseRequestRaw_ContentIdentification_ExistingLicense)(nil), // 61: LicenseRequestRaw.ContentIdentification.ExistingLicense + (*FileHashes_Signature)(nil), // 62: FileHashes.Signature +} +var file_wv_proto2_proto_depIdxs = []int32{ + 2, // 0: ClientIdentification.Type:type_name -> ClientIdentification.TokenType + 37, // 1: ClientIdentification.Token:type_name -> SignedDeviceCertificate + 46, // 2: ClientIdentification.ClientInfo:type_name -> ClientIdentification.NameValue + 47, // 3: ClientIdentification._ClientCapabilities:type_name -> ClientIdentification.ClientCapabilities + 45, // 4: ClientIdentification._FileHashes:type_name -> FileHashes + 4, // 5: DeviceCertificate.Type:type_name -> DeviceCertificate.CertificateType + 5, // 6: DeviceCertificateStatus.Status:type_name -> DeviceCertificateStatus.CertificateStatus + 29, // 7: DeviceCertificateStatus.DeviceInfo:type_name -> ProvisionedDeviceInfo + 21, // 8: DeviceCertificateStatusList.CertificateStatus:type_name -> DeviceCertificateStatus + 0, // 9: LicenseIdentification.Type:type_name -> LicenseType + 24, // 10: License.Id:type_name -> LicenseIdentification + 48, // 11: License._Policy:type_name -> License.Policy + 49, // 12: License.Key:type_name -> License.KeyContainer + 9, // 13: LicenseError.ErrorCode:type_name -> LicenseError.Error + 19, // 14: LicenseRequest.ClientId:type_name -> ClientIdentification + 54, // 15: LicenseRequest.ContentId:type_name -> LicenseRequest.ContentIdentification + 10, // 16: LicenseRequest.Type:type_name -> LicenseRequest.RequestType + 1, // 17: LicenseRequest.ProtocolVersion:type_name -> ProtocolVersion + 23, // 18: LicenseRequest.EncryptedClientId:type_name -> EncryptedClientIdentification + 19, // 19: LicenseRequestRaw.ClientId:type_name -> ClientIdentification + 58, // 20: LicenseRequestRaw.ContentId:type_name -> LicenseRequestRaw.ContentIdentification + 11, // 21: LicenseRequestRaw.Type:type_name -> LicenseRequestRaw.RequestType + 1, // 22: LicenseRequestRaw.ProtocolVersion:type_name -> ProtocolVersion + 23, // 23: LicenseRequestRaw.EncryptedClientId:type_name -> EncryptedClientIdentification + 12, // 24: ProvisionedDeviceInfo.SecurityLevel:type_name -> ProvisionedDeviceInfo.WvSecurityLevel + 23, // 25: RemoteAttestation.Certificate:type_name -> EncryptedClientIdentification + 20, // 26: SignedDeviceCertificate._DeviceCertificate:type_name -> DeviceCertificate + 37, // 27: SignedDeviceCertificate.Signer:type_name -> SignedDeviceCertificate + 13, // 28: SignedMessage.Type:type_name -> SignedMessage.MessageType + 33, // 29: SignedMessage.RemoteAttestation:type_name -> RemoteAttestation + 14, // 30: WidevineCencHeader.algorithm:type_name -> WidevineCencHeader.Algorithm + 15, // 31: SignedLicenseRequest.Type:type_name -> SignedLicenseRequest.MessageType + 27, // 32: SignedLicenseRequest.Msg:type_name -> LicenseRequest + 33, // 33: SignedLicenseRequest.RemoteAttestation:type_name -> RemoteAttestation + 16, // 34: SignedLicenseRequestRaw.Type:type_name -> SignedLicenseRequestRaw.MessageType + 28, // 35: SignedLicenseRequestRaw.Msg:type_name -> LicenseRequestRaw + 33, // 36: SignedLicenseRequestRaw.RemoteAttestation:type_name -> RemoteAttestation + 17, // 37: SignedLicense.Type:type_name -> SignedLicense.MessageType + 25, // 38: SignedLicense.Msg:type_name -> License + 33, // 39: SignedLicense.RemoteAttestation:type_name -> RemoteAttestation + 18, // 40: SignedServiceCertificate.Type:type_name -> SignedServiceCertificate.MessageType + 37, // 41: SignedServiceCertificate.Msg:type_name -> SignedDeviceCertificate + 33, // 42: SignedServiceCertificate.RemoteAttestation:type_name -> RemoteAttestation + 62, // 43: FileHashes.signatures:type_name -> FileHashes.Signature + 3, // 44: ClientIdentification.ClientCapabilities.MaxHdcpVersion:type_name -> ClientIdentification.ClientCapabilities.HdcpVersion + 6, // 45: License.KeyContainer.Type:type_name -> License.KeyContainer.KeyType + 7, // 46: License.KeyContainer.Level:type_name -> License.KeyContainer.SecurityLevel + 50, // 47: License.KeyContainer.RequiredProtection:type_name -> License.KeyContainer.OutputProtection + 50, // 48: License.KeyContainer.RequestedProtection:type_name -> License.KeyContainer.OutputProtection + 51, // 49: License.KeyContainer._KeyControl:type_name -> License.KeyContainer.KeyControl + 52, // 50: License.KeyContainer._OperatorSessionKeyPermissions:type_name -> License.KeyContainer.OperatorSessionKeyPermissions + 53, // 51: License.KeyContainer.VideoResolutionConstraints:type_name -> License.KeyContainer.VideoResolutionConstraint + 3, // 52: License.KeyContainer.OutputProtection.Hdcp:type_name -> ClientIdentification.ClientCapabilities.HdcpVersion + 8, // 53: License.KeyContainer.OutputProtection.CgmsFlags:type_name -> License.KeyContainer.OutputProtection.CGMS + 50, // 54: License.KeyContainer.VideoResolutionConstraint.RequiredProtection:type_name -> License.KeyContainer.OutputProtection + 55, // 55: LicenseRequest.ContentIdentification.CencId:type_name -> LicenseRequest.ContentIdentification.CENC + 56, // 56: LicenseRequest.ContentIdentification.WebmId:type_name -> LicenseRequest.ContentIdentification.WebM + 57, // 57: LicenseRequest.ContentIdentification.License:type_name -> LicenseRequest.ContentIdentification.ExistingLicense + 40, // 58: LicenseRequest.ContentIdentification.CENC.Pssh:type_name -> WidevineCencHeader + 0, // 59: LicenseRequest.ContentIdentification.CENC.LicenseType:type_name -> LicenseType + 0, // 60: LicenseRequest.ContentIdentification.WebM.LicenseType:type_name -> LicenseType + 24, // 61: LicenseRequest.ContentIdentification.ExistingLicense.LicenseId:type_name -> LicenseIdentification + 59, // 62: LicenseRequestRaw.ContentIdentification.CencId:type_name -> LicenseRequestRaw.ContentIdentification.CENC + 60, // 63: LicenseRequestRaw.ContentIdentification.WebmId:type_name -> LicenseRequestRaw.ContentIdentification.WebM + 61, // 64: LicenseRequestRaw.ContentIdentification.License:type_name -> LicenseRequestRaw.ContentIdentification.ExistingLicense + 0, // 65: LicenseRequestRaw.ContentIdentification.CENC.LicenseType:type_name -> LicenseType + 0, // 66: LicenseRequestRaw.ContentIdentification.WebM.LicenseType:type_name -> LicenseType + 24, // 67: LicenseRequestRaw.ContentIdentification.ExistingLicense.LicenseId:type_name -> LicenseIdentification + 68, // [68:68] is the sub-list for method output_type + 68, // [68:68] is the sub-list for method input_type + 68, // [68:68] is the sub-list for extension type_name + 68, // [68:68] is the sub-list for extension extendee + 0, // [0:68] is the sub-list for field type_name +} + +func init() { file_wv_proto2_proto_init() } +func file_wv_proto2_proto_init() { + if File_wv_proto2_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_wv_proto2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClientIdentification); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeviceCertificate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeviceCertificateStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeviceCertificateStatusList); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EncryptedClientIdentification); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseIdentification); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*License); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseError); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequestRaw); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProvisionedDeviceInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProvisioningOptions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProvisioningRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProvisioningResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RemoteAttestation); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SessionInit); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SessionState); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignedCertificateStatusList); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignedDeviceCertificate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignedProvisioningMessage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignedMessage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WidevineCencHeader); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignedLicenseRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignedLicenseRequestRaw); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignedLicense); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SignedServiceCertificate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FileHashes); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClientIdentification_NameValue); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ClientIdentification_ClientCapabilities); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*License_Policy); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*License_KeyContainer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*License_KeyContainer_OutputProtection); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*License_KeyContainer_KeyControl); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*License_KeyContainer_OperatorSessionKeyPermissions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*License_KeyContainer_VideoResolutionConstraint); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequest_ContentIdentification); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequest_ContentIdentification_CENC); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequest_ContentIdentification_WebM); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequest_ContentIdentification_ExistingLicense); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequestRaw_ContentIdentification); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequestRaw_ContentIdentification_CENC); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequestRaw_ContentIdentification_WebM); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*LicenseRequestRaw_ContentIdentification_ExistingLicense); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_wv_proto2_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FileHashes_Signature); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_wv_proto2_proto_rawDesc, + NumEnums: 19, + NumMessages: 44, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_wv_proto2_proto_goTypes, + DependencyIndexes: file_wv_proto2_proto_depIdxs, + EnumInfos: file_wv_proto2_proto_enumTypes, + MessageInfos: file_wv_proto2_proto_msgTypes, + }.Build() + File_wv_proto2_proto = out.File + file_wv_proto2_proto_rawDesc = nil + file_wv_proto2_proto_goTypes = nil + file_wv_proto2_proto_depIdxs = nil +}