38 |
39 | {% block content %}
40 | {% endblock %}
41 |
42 |
43 |
44 |
45 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
--------------------------------------------------------------------------------
/manager/templates/index.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 |
3 | {% block content %}
4 |
5 |
6 |
7 |
8 |
9 | {% endblock %}
10 |
--------------------------------------------------------------------------------
/manager/templates/metrics.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 |
3 | {% block content %}
4 |
5 | {{ metrics['executions'] }} Total Bro Executions ({{metrics['cache_hits']}} from cache)
6 | 7 |By Version
8 |
9 |
10 |
11 |
25 |
26 |
27 | | Version | 13 |Executions | 14 |
|---|---|
| {{ v }} | 20 |{{ execs }} | 21 |
By Date
28 |
29 |
30 |
31 |
45 |
46 |
47 | {% endblock %}
48 |
--------------------------------------------------------------------------------
/manager/test_format.py:
--------------------------------------------------------------------------------
1 | import unittest
2 | from format import fmt
3 |
4 | class TestFormat(unittest.TestCase):
5 |
6 | def test_cases(self):
7 | cases = [
8 | ('event zeek_init(){}', None),
9 | ('event zeek_init(){', {'row': 0, 'column': 18, 'type': 'error', 'text': 'missing grammar node "}" on line 0, col 18'}),
10 | ('function foo(){}', None),
11 | ('function foo({}', {'row': 0, 'column': 13, 'type': 'error', 'text': 'missing grammar node ")" on line 0, col 13'}),
12 | ]
13 | for case, expected in cases:
14 | with self.subTest(txt=case):
15 | _, error = fmt(case)
16 | self.assertEqual(error, expected)
17 |
18 | if __name__ == '__main__':
19 | unittest.main()
20 |
--------------------------------------------------------------------------------
/manager/version.py:
--------------------------------------------------------------------------------
1 | """
2 | Zeek version helper.
3 |
4 | All available Zeek versions are stored within the zeek:versions set
5 | in Redis. This script polls the Docker Hub API once in a while and
6 | fetches all new tags using docker-py.
7 | """
8 | import argparse
9 | import logging
10 | import packaging.version
11 | import re
12 | import time
13 | import typing
14 |
15 | import docker
16 | import requests
17 |
18 | from common import get_redis
19 |
20 | logger = logging.getLogger(__name__)
21 |
22 | NAMESPACE = "zeek"
23 | REPO = "zeek"
24 | TAGS_URL = f"https://hub.docker.com/v2/namespaces/{NAMESPACE}/repositories/{REPO}/tags"
25 |
26 | REDIS_VERSION_KEY = "zeek:versions"
27 |
28 |
29 | def is_acceptable_zeek_version(version: str):
30 | """
31 | For now, just the three digit version tags, avoiding the 6.0, lts
32 | and amd64 / arm64 architecture ones.
33 | """
34 | return re.match(r"^[0-9]+\.[0-9]+\.[0-9]+$", version) is not None
35 |
36 |
37 | def zeek_versions_from_redis() -> typing.Tuple[str, list[str]]:
38 | """
39 | Return versions found in Redis as tuple (default, all).
40 | """
41 | redis = get_redis()
42 | versions = sorted(redis.smembers(REDIS_VERSION_KEY), key=packaging.version.parse)
43 | default = versions[-1] if len(versions) > 0 else None
44 | if versions == "master" and len(versions) > 1:
45 | return versions[-2]
46 |
47 | return default, versions
48 |
49 |
50 | def pull_new_tags():
51 | """
52 | Fetch all tags from Docker Hub and pull those we do no know about yet.
53 |
54 | https://docs.docker.com/docker-hub/api/latest/#tag/repositories/paths/%7E1v2%7E1namespaces%7E1%7Bnamespace%7D%7E1repositories%7E1%7Brepository%7D%7E1tags/get
55 | """
56 | # We only fetch the first page to avoid unnecessarily using up space.
57 | max_page = 1
58 |
59 | session = requests.Session()
60 | redis = get_redis()
61 | docker_client = docker.Client()
62 |
63 | _, known_versions = zeek_versions_from_redis()
64 | logger.info("known_versions: %s", known_versions)
65 |
66 | for page in range(1, max_page + 1):
67 | logger.debug("Fetching tags, page %s", page)
68 | response = session.get(TAGS_URL, params={"page": page}, timeout=30)
69 |
70 | if response.status_code == 404:
71 | logger.debug("No more pages")
72 | break
73 |
74 | response.raise_for_status()
75 |
76 | for result in response.json()["results"]:
77 | version = result["name"]
78 |
79 | if not is_acceptable_zeek_version(version):
80 | logger.debug("Ignoring image tag %r", version)
81 | continue
82 |
83 | if version in known_versions:
84 | logger.debug("Ignoring known image tag %r", version)
85 | continue
86 |
87 | logger.info("Pulling new image %s", version)
88 | docker_client.pull(f"{NAMESPACE}/{REPO}", tag=version)
89 |
90 | redis.sadd(REDIS_VERSION_KEY, version)
91 |
92 |
93 | def sync_docker_versions_to_redis():
94 | """
95 | List locally available container images and store their tags in Redis.
96 | """
97 | redis = get_redis()
98 | docker_client = docker.Client()
99 |
100 | images = docker_client.images(name="zeek/zeek")
101 | tags = []
102 | for i in images:
103 | tags.extend(i["RepoTags"])
104 |
105 | versions = [t.replace("zeek/zeek:", "") for t in tags if "_" not in t]
106 | versions = [v for v in versions if is_acceptable_zeek_version(v)]
107 |
108 | if versions:
109 | redis.sadd(REDIS_VERSION_KEY, *versions)
110 |
111 | # Now, also fetch all versions from Redis and remove those
112 | # not available to Docker anymore.
113 | _, redis_versions = zeek_versions_from_redis()
114 | for rv in redis_versions:
115 | if rv not in versions:
116 | logger.info("Deleting %r from Redis", rv)
117 | redis.srem(REDIS_VERSION_KEY, rv)
118 |
119 |
120 | def main():
121 | """
122 | Entry point.
123 | """
124 | parser = argparse.ArgumentParser()
125 | parser.add_argument("-i", "--interval", type=int, default=67 * 60)
126 | parser.add_argument("-l", "--log-level", type=str, default="info")
127 | args = parser.parse_args()
128 |
129 | logging.basicConfig(level=getattr(logging, args.log_level.upper()))
130 | while True:
131 | sync_docker_versions_to_redis()
132 | pull_new_tags()
133 | try:
134 | time.sleep(args.interval)
135 | except KeyboardInterrupt:
136 | logger.info("Interrupt")
137 | break
138 |
139 |
140 | if __name__ == "__main__":
141 | main()
142 |
--------------------------------------------------------------------------------
/manager/web-ui/.gitignore:
--------------------------------------------------------------------------------
1 | # See http://help.github.com/ignore-files/ for more about ignoring files.
2 |
3 | # dependencies
4 | node_modules
5 |
6 | # testing
7 | coverage
8 |
9 | # production
10 | build
11 |
12 | # misc
13 | .DS_Store
14 | .env
15 | npm-debug.log
16 |
--------------------------------------------------------------------------------
/manager/web-ui/Makefile:
--------------------------------------------------------------------------------
1 | all:
2 | npm install
3 | npm run build
4 |
5 | dev:
6 | REACT_APP_TRY_BRO_API_HOST=http://192.168.59.103 npm start
7 |
--------------------------------------------------------------------------------
/manager/web-ui/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "try-bro",
3 | "version": "0.1.0",
4 | "private": true,
5 | "dependencies": {
6 | "@fortawesome/fontawesome-svg-core": "^6.2.0",
7 | "@fortawesome/free-regular-svg-icons": "^6.2.0",
8 | "@fortawesome/free-solid-svg-icons": "^6.2.0",
9 | "@fortawesome/react-fontawesome": "^0.2.0",
10 | "ajv-keywords": "^5.1.0",
11 | "babel-plugin-macros": "^3.1.0",
12 | "bootstrap": "^5.2.2",
13 | "brace": "^0.11.1",
14 | "history": "^5.3.0",
15 | "isomorphic-fetch": "^3.0.0",
16 | "md5": "^2.3.0",
17 | "query-string": "^7.1.1",
18 | "react": "^18.2.0",
19 | "react-ace": "^10.1.0",
20 | "react-bootstrap": "^2.6.0",
21 | "react-dom": "^18.2.0",
22 | "react-overlays": "^5.2.1",
23 | "react-redux": "^8.0.5",
24 | "react-router-dom": "^6.4.3",
25 | "react-scripts": "^5.0.1",
26 | "redux": "^4.2.0",
27 | "redux-logger": "^2.7.0",
28 | "redux-thunk": "^2.4.2"
29 | },
30 | "scripts": {
31 | "start": "react-scripts start",
32 | "build": "react-scripts build",
33 | "test": "react-scripts test --env=jsdom",
34 | "eject": "react-scripts eject"
35 | },
36 | "browserslist": {
37 | "production": [
38 | ">0.2%",
39 | "not dead",
40 | "not op_mini all"
41 | ],
42 | "development": [
43 | "last 1 chrome version",
44 | "last 1 firefox version",
45 | "last 1 safari version"
46 | ]
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/manager/web-ui/public/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zeek/try-zeek/764c096477c823348b20dc5bf4b2b2586deba6ce/manager/web-ui/public/favicon.ico
--------------------------------------------------------------------------------
/manager/web-ui/public/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
16 | | Date | 33 |Executions | 34 |
|---|---|
| {{ d }} | 40 |{{ execs }} | 41 |
20 |
21 | onChange(example.prev.path)}>Previous : null;
125 | var next = example.next ? onChange(example.next.path)}>Next : null;
126 | return (
127 |
143 |
144 |
160 | )
161 | }
162 |
163 | class BroFileViewerModal extends Component {
164 |
165 | render() {
166 | const { file, recordNum, onPrev, onNext } = this.props;
167 | var record = null;
168 | var rowStatus = null;
169 | if (file && file.rows && file.rows.length && recordNum !== null) {
170 | var row = file.rows[recordNum]
171 | record = zip([file.header, file.types, row]);
172 | rowStatus = Viewing record {recordNum+1} of {file.rows.length};
173 | }
174 | return (
175 |
176 |
177 |
178 |
179 |
180 |
181 |
182 | {rowStatus}
183 |
184 |
185 |
186 |
188 |
189 |
190 |
191 |
192 | );
193 | }
194 | }
195 |
196 | class BroFileViewerTableTable extends Component {
197 | shouldComponentUpdate () {
198 | return false;
199 | }
200 |
201 | render() {
202 | const { file, onRowSelected } = this.props;
203 | return (
204 |
205 |
206 |
222 | )
223 | }
224 | }
225 |
226 | class BroFileViewerTable extends Component {
227 | constructor(props) {
228 | super(props);
229 | this.state = {showDetail: false, detailRecordNum: null};
230 | }
231 | showDetails = (file, record, row) => {
232 | this.setState({showDetail: true, detailRecordNum: row});
233 | }
234 | hideDetails = () => {
235 | this.setState({showDetail: false});
236 | }
237 | showPrev = () => {
238 | this.setState({detailRecordNum: this.state.detailRecordNum-1});
239 | }
240 | showNext = () => {
241 | this.setState({detailRecordNum: this.state.detailRecordNum+1});
242 | }
243 | render() {
244 | const { file } = this.props;
245 | return (
246 |
382 | { ' ' }
383 | {showHide}
384 |
385 | );
386 | }
387 |
388 | renderCodeRow() {
389 | const { versions, examples, code, pcap, exec } = this.props;
390 | var editor =
401 |
402 | {editor}
403 |
404 |
405 |
406 |
410 | { ' ' }
411 | Or { ' ' }
412 |
415 |
416 | { ' ' }
417 |
420 |
421 | ;
422 |
423 |
424 | if(examples.example && examples.example.html && !examples.hidden) {
425 | return (
426 |
427 |
434 | );
435 | } else {
436 | return (
437 |
438 |
442 | );
443 | }
444 | }
445 | render() {
446 | const { exec } = this.props;
447 | return (
448 |
449 | {this.renderLoadLine()}
450 |
451 | {this.renderCodeRow()} 452 |
456 | );
457 | }
458 | }
459 |
460 | function zip(arrays) {
461 | return arrays[0].map(function(_,i){
462 | return arrays.map(function(array){return array[i]})
463 | });
464 | }
465 |
466 | function mapStateToProps(state) {
467 | return {
468 | versions: state.versions,
469 | examples: state.examples,
470 | code: state.code,
471 | pcap: state.pcap,
472 | exec: state.exec
473 | };
474 | }
475 |
476 | export default connect(mapStateToProps)(App);
477 |
--------------------------------------------------------------------------------
/manager/web-ui/src/App.test.js:
--------------------------------------------------------------------------------
1 | import React from 'react';
2 | import ReactDOM from 'react-dom';
3 | import {App} from './App';
4 |
5 | import tryBroApp from './reducers';
6 |
7 | it('renders without crashing', () => {
8 | const div = document.createElement('div');
9 | var props = tryBroApp(undefined, {type:null})
10 | ReactDOM.render(
36 | ,
38 | rootElement
39 | );
40 |
41 |
--------------------------------------------------------------------------------
/manager/web-ui/src/logo.svg:
--------------------------------------------------------------------------------
1 |
8 |
--------------------------------------------------------------------------------
/manager/web-ui/src/reducers.js:
--------------------------------------------------------------------------------
1 | import { combineReducers } from 'redux';
2 | import { VERSIONS_FETCHING, VERSIONS_FETCHED, VERSIONS_SET } from './actions';
3 | import { EXAMPLES_FETCHING, EXAMPLES_FETCHED, EXAMPLE_SELECTED, EXAMPLE_HIDE, EXAMPLE_SHOW } from './actions';
4 | import { CODE_SET, CODE_ADD_FILE, CODE_SELECT_FILE, CODE_RENAME_FILE, CODE_EDIT_FILE } from './actions';
5 | import { EXEC_RUNNING, EXEC_COMPLETE, EXEC_FETCHING_FILES, EXEC_FETCHED_FILES, EXEC_RESET, EXEC_SET_ERRORS } from './actions';
6 | import { PCAP_FETCHING, PCAP_FETCHED, PCAP_SELECTED, PCAP_FILE_CHANGED, PCAP_UPLOAD_PROGRESS, PCAP_UPLOADED } from './actions';
7 | import { parse_errors } from './broutil';
8 |
9 | const initialVersionState = {
10 | fetching: false,
11 | versions: [],
12 | version: null
13 | };
14 |
15 | const initialExampleState = {
16 | fetching: false,
17 | fetched: false,
18 | examples: [],
19 | example: null,
20 | hidden: false
21 | }
22 | const initialCodeState = {
23 | sources: [{name:'main.zeek', content:''}],
24 | current: 'main.zeek',
25 | newCounter: 1
26 | }
27 |
28 | const initialExecState = {
29 | status: null,
30 | mode: 'text',
31 | stdout: null,
32 | stderr: null,
33 | files: null,
34 | visible: null,
35 | job: null,
36 | errors: {},
37 | }
38 |
39 | const initialPcapState = {
40 | pcap: null,
41 | file: null,
42 | fetching: null,
43 | fetched: false,
44 | available: [],
45 | uploaded: false,
46 | uploading: false,
47 | upload_progress: null,
48 | }
49 |
50 | function versions(state = initialVersionState, action) {
51 | switch (action.type) {
52 | case VERSIONS_SET:
53 | return Object.assign({}, state, {
54 | version: action.version
55 | });
56 | case VERSIONS_FETCHING:
57 | return Object.assign({}, state, {
58 | fetching: true,
59 | });
60 | case VERSIONS_FETCHED:
61 | return Object.assign({}, state, {
62 | fetching: false,
63 | versions: action.versions,
64 | version: action.version
65 | });
66 | default:
67 | return state;
68 | }
69 | }
70 |
71 | function examples(state = initialExampleState, action) {
72 | switch (action.type) {
73 | case EXAMPLES_FETCHING:
74 | return Object.assign({}, state, {
75 | fetching: true,
76 | });
77 | case EXAMPLES_FETCHED:
78 | return Object.assign({}, state, {
79 | fetching: false,
80 | examples: action.examples,
81 | fetched: true,
82 | });
83 | case EXAMPLE_SELECTED:
84 | var ex = state.examples.filter((e) => {
85 | return e.path === action.path;
86 | })[0];
87 | if (ex === undefined) {
88 | return state;
89 | }
90 | return { ...state,
91 | example: ex,
92 | }
93 | case EXAMPLE_HIDE:
94 | return Object.assign({}, state, {
95 | hidden: true,
96 | });
97 | case EXAMPLE_SHOW:
98 | return Object.assign({}, state, {
99 | hidden: false,
100 | });
101 | default:
102 | return state;
103 | }
104 | }
105 |
106 | function code(state = initialCodeState, action) {
107 | console.log(state, action);
108 | switch (action.type) {
109 | case CODE_SET:
110 | return Object.assign({}, state, {
111 | sources: action.sources,
112 | current: action.sources[0].name,
113 | newCounter: action.sources.length
114 | });
115 | case CODE_ADD_FILE:
116 | var new_filename = `new-${state.newCounter}.zeek`;
117 | return Object.assign({}, state, {
118 | sources: [...state.sources, {name: new_filename, content: '#'}],
119 | current: new_filename,
120 | newCounter: state.newCounter + 1
121 | });
122 | case CODE_RENAME_FILE:
123 | var new_sources = [];
124 | state.sources.map( s => {
125 | if(s.name !== state.current) {
126 | new_sources.push(s);
127 | } else {
128 | new_sources.push({
129 | name: action.new_name,
130 | content: s.content
131 | })
132 | }
133 | })
134 | return Object.assign({}, state, {
135 | sources: new_sources,
136 | current: action.new_name
137 | })
138 | case CODE_SELECT_FILE:
139 | return Object.assign({}, state, {
140 | current: action.name
141 | });
142 | case CODE_EDIT_FILE:
143 | var new_sources = [];
144 | state.sources.map( s => {
145 | if(s.name !== action.name) {
146 | new_sources.push(s);
147 | } else {
148 | new_sources.push({
149 | name: action.name,
150 | content: action.contents
151 | })
152 | }
153 | })
154 | return Object.assign({}, state, {
155 | sources: new_sources
156 | })
157 | default:
158 | return state;
159 | }
160 | }
161 |
162 | function exec(state = initialExecState, action) {
163 | switch (action.type) {
164 | case EXEC_RESET:
165 | return initialExecState;
166 | case EXEC_RUNNING:
167 | return Object.assign({}, state, {
168 | status: 'Running...',
169 | files: null,
170 | stdout: null,
171 | stderr: null
172 | });
173 | case EXEC_COMPLETE:
174 | return Object.assign({}, state, {
175 | stdout: action.response.stdout,
176 | job: action.response.job,
177 | status: null,
178 | });
179 | case EXEC_FETCHING_FILES:
180 | return Object.assign({}, state, {
181 | status: 'Fetching files...'
182 | });
183 | case EXEC_FETCHED_FILES:
184 | var files = action.files;
185 | var stderr = files['stderr.log'];
186 | delete(files['stderr.log']);
187 | delete(files['stdout.log']);
188 | return Object.assign({}, state, {
189 | status: null,
190 | files: files,
191 | stderr: stderr,
192 | errors: parse_errors(stderr)
193 | });
194 | case EXEC_SET_ERRORS:
195 | return Object.assign({}, state, {
196 | errors: action.errors
197 | });
198 | default:
199 | return state;
200 | }
201 | }
202 |
203 | function pcap(state = initialPcapState, action) {
204 | switch (action.type) {
205 | case PCAP_FETCHING:
206 | return Object.assign({}, state, {
207 | fetching: true,
208 | });
209 | case PCAP_FETCHED:
210 | return Object.assign({}, state, {
211 | fetching: false,
212 | fetched: true,
213 | available: action.available,
214 | });
215 | case PCAP_SELECTED:
216 | return { ...state,
217 | pcap: action.pcap,
218 | file: null,
219 | uploaded: false
220 | }
221 | case PCAP_FILE_CHANGED:
222 | return { ...state,
223 | pcap: null,
224 | file: action.file,
225 | too_large: action.file.size > 10*1024*1024,
226 | uploaded: false,
227 | uploading: false,
228 | upload_progress: null,
229 | }
230 | case PCAP_UPLOAD_PROGRESS:
231 | return { ...state,
232 | uploaded: false,
233 | uploading: true,
234 | upload_progress: action.pct,
235 | }
236 | case PCAP_UPLOADED:
237 | return { ...state,
238 | pcap: action.checksum,
239 | uploaded: true,
240 | uploading: false,
241 | upload_progress: null,
242 | }
243 | default:
244 | return state;
245 | }
246 | }
247 |
248 | const tryBroApp = combineReducers({
249 | versions,
250 | examples,
251 | code,
252 | pcap,
253 | exec
254 | });
255 |
256 | export default tryBroApp;
257 |
258 |
--------------------------------------------------------------------------------
/manager/web-ui/src/tbhistory.js:
--------------------------------------------------------------------------------
1 | import { createHashHistory } from 'history'
2 | import queryString from 'query-string'
3 |
4 | export const tbhistory = createHashHistory();
5 |
6 | export function setHistoryToExample(example) {
7 | var q = queryString.stringify({example: example});
8 | tbhistory.push({pathname: '/', search: q});
9 | }
10 |
--------------------------------------------------------------------------------
/manager/worker.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3 -u
2 | import asyncio
3 | import codecs
4 | import docker
5 | import hashlib
6 | import json
7 | import os
8 | import shutil
9 | import time
10 | import tempfile
11 | import traceback
12 | import rq
13 |
14 | from common import get_cache_key, get_redis, get_redis_raw
15 | from version import zeek_versions_from_redis
16 |
17 | CACHE_EXPIRE = 60*10
18 | SOURCES_EXPIRE = 60*60*24*30
19 |
20 | r = get_redis()
21 | r_raw = get_redis_raw()
22 |
23 | background_tasks = set()
24 |
25 |
26 | def read_fn(fn):
27 | with open(fn) as f:
28 | return f.read()
29 |
30 |
31 | def get_bro_versions():
32 | c = docker.Client()
33 | images = c.images(name='zeek/zeek')
34 | tags = [i['RepoTags'][0] for i in images]
35 | versions = [t.replace("zeek/zeek:", "") for t in tags if '_' not in t]
36 | return sorted(versions)
37 |
38 | def get_pcap(checksum):
39 | pcap_key = "pcaps:%s" % checksum
40 | r_raw.expire(pcap_key, 60*60)
41 | return r_raw.get(pcap_key)
42 |
43 | def get_pcap_with_retry(checksum):
44 | """There is an annoying race condition where POST /pcap/upload is returning as soon as the pcap is sent, but before
45 | the request is complete and redis has actually saved it. then run_code
46 | doesn't find it. so for now, retry here and see if it shows up"""
47 |
48 | for x in range(10):
49 | contents = get_pcap(checksum)
50 | if contents:
51 | return contents
52 | time.sleep(0.1)
53 | return None
54 |
55 |
56 | def run_code(sources, pcap=None, version=None):
57 | if not version: # Assume backend.py set this properly.
58 | raise RuntimeError("version is missing")
59 |
60 | job = rq.get_current_job()
61 | if type(job) is bytes:
62 | job = job.decode()
63 | return really_run_code(job.id, sources, pcap=pcap, version=version)
64 |
65 |
66 | def really_run_code(job_id, sources, pcap, version):
67 | cache_key = get_cache_key(sources, pcap, version)
68 | stdout_key = 'stdout:%s' % job_id
69 | files_key = 'files:%s' % job_id
70 | sources_key = 'sources:%s' % job_id
71 |
72 | file_output = run_code_docker(sources, pcap, version)
73 |
74 | stdout=""
75 | for f, txt in file_output.items():
76 | if not f.endswith(".log"): continue
77 | r.hset(files_key, f, txt)
78 | if f == 'stdout.log':
79 | stdout = txt
80 | r.expire(files_key, CACHE_EXPIRE+5)
81 |
82 | r.set(stdout_key, stdout)
83 | r.expire(stdout_key, CACHE_EXPIRE+5)
84 |
85 | r.set(sources_key, json.dumps(dict(sources=sources, pcap=pcap, version=version)))
86 | r.expire(sources_key, SOURCES_EXPIRE)
87 |
88 | r.set(cache_key, job_id)
89 | r.expire(cache_key, CACHE_EXPIRE)
90 | return stdout
91 |
92 | def run_code_docker(sources, pcap=None, version=None):
93 | with tempfile.TemporaryDirectory(dir="/brostuff") as work_dir:
94 | return _run_code_docker(sources, pcap=pcap, version=version, work_dir=work_dir)
95 | def _run_code_docker(sources, pcap, version, work_dir):
96 | default_version, versions = zeek_versions_from_redis()
97 | if version not in versions:
98 | print(f"Warning: {version!r} not available, using {default_version!r}")
99 | version = default_version
100 |
101 | for s in sources:
102 | s['content'] = s['content'].replace("\r\n", "\n")
103 | s['content'] = s['content'].rstrip() + "\n"
104 |
105 | runbro_path = os.path.join(work_dir, "runbro")
106 | for s in sources:
107 | code_fn = os.path.join(work_dir, s['name'])
108 | with codecs.open(code_fn, 'w', encoding="utf-8") as f:
109 | f.write(s['content'])
110 |
111 | runbro_src = "./runbro"
112 | runbro_src_version_specific = "%s-%s" % (runbro_src, version)
113 | if os.path.exists(runbro_src_version_specific):
114 | runbro_src = runbro_src_version_specific
115 |
116 | shutil.copy(runbro_src, runbro_path)
117 | os.chmod(runbro_path, 0o755)
118 |
119 | binds = {work_dir: {"bind": work_dir, "mode": "rw"}}
120 |
121 | if pcap:
122 | dst = os.path.join(work_dir, "file.pcap")
123 | if '.' in pcap:
124 | src = os.path.join(os.getcwd(), "static/pcaps", pcap)
125 | #FIXME: Work out a better way to share pcaps around
126 | #binds[src]={"bind": dst, "ro": True}
127 | shutil.copy(src, dst)
128 | else:
129 | contents = get_pcap_with_retry(pcap)
130 | if contents:
131 | with open(dst, 'wb') as f:
132 | f.write(contents)
133 |
134 | #docker run -v /brostuff/tmpWh0k1x:/brostuff/ -n --rm -t -i bro_worker /bro/bin/bro /brostuff/code.bro
135 |
136 | print("Connecting to docker....")
137 | c = docker.Client()
138 |
139 | print("Creating Bro %s container.." % version)
140 | host_config = docker.utils.create_host_config(
141 | binds=binds,
142 | dns=["127.0.0.1"],
143 | mem_limit="128m",
144 | network_mode="none",
145 | read_only=True,
146 | )
147 | container = c.create_container('zeek/zeek:' + version,
148 | working_dir=work_dir,
149 | command=runbro_path,
150 | host_config=host_config,
151 | volumes=[work_dir],
152 | )
153 | print("Starting container..")
154 | try:
155 | c.start(container)
156 |
157 | print("Waiting..")
158 | c.wait(container)
159 |
160 | finally:
161 | print("Removing Container")
162 | c.remove_container(container)
163 |
164 | files = {}
165 | for f in os.listdir(work_dir):
166 | if not f.endswith(".log"): continue
167 | full = os.path.join(work_dir, f)
168 | txt = read_fn(full)
169 | if txt.strip() or 'stdout' in f:
170 | files[f] = txt
171 | return files
172 |
--------------------------------------------------------------------------------
/tryzeek.service:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=TryZeek
3 | After=docker.service
4 | Requires=docker.service
5 |
6 | [Service]
7 | TimeoutStartSec=0
8 | #ExecStartPre=-/usr/bin/docker kill trybro
9 | #ExecStartPre=-/usr/bin/docker rm trybro
10 | WorkingDirectory=/root/try-zeek
11 | RemainAfterExit=yes
12 | Type=oneshot
13 | Environment=TRYZEEK_DATA=/srv/tryzeek_data
14 | # Set this if you need a different SITE_ADDRESS that is used by caddy:
15 | # Environment=SITE_ADDRESS=try.zeek.example.com:443
16 | ExecStart=docker-compose up -d --scale worker=4
17 | ExecStop=docker-compose down
18 |
19 | [Install]
20 | WantedBy=multi-user.target
21 |
--------------------------------------------------------------------------------
22 |
23 | 
24 |
25 |
26 |
24 |
25 |
27 |
28 |
29 |
39 |
40 |
41 |
--------------------------------------------------------------------------------
/manager/web-ui/public/mode-zeek.js:
--------------------------------------------------------------------------------
1 | ace.define('ace/mode/zeek_highlight_rules', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(acequire, exports, module) {
2 |
3 | var oop = acequire("../lib/oop");
4 | var TextHighlightRules = acequire("./text_highlight_rules").TextHighlightRules;
5 |
6 | var ZeekHighlightRules = function() {
7 | // regexp must not have capturing parentheses. Use (?:) instead.
8 | // regexps are ordered -> the first match is used
9 |
10 | this.$rules = {
11 | "start": [
12 | {
13 | token: "comment.line",
14 | regex: "#.*$"
15 | },
16 | {
17 | token: "string.double",
18 | regex: /"/,
19 | next: "string-state"
20 | },
21 | {
22 | token: "string.regexp",
23 | regex: "(/)(?=.*/)",
24 | next: "pattern-state"
25 | },
26 | {
27 | token: ["keyword.other", "meta.preprocessor"],
28 | regex: /(@(?:load-plugin|load-sigs|load|unload))(.*$)/
29 | },
30 | {
31 | token: "keyword.other",
32 | regex: /@(?:DEBUG|DIR|FILENAME|deprecated|if|ifdef|ifndef|else|endif)/
33 | },
34 | {
35 | token: [
36 | "keyword.other",
37 | "meta.preprocessor",
38 | "keyword.operator",
39 | "meta.preprocessor"
40 | ],
41 | regex: /(@prefixes)(\s*)(\+?=)(.*$)/
42 | },
43 | {
44 | token: "storage.modifier.attribute",
45 | regex: /\&\b(?:redef|priority|log|optional|default|add_func|delete_func|expire_func|read_expire|write_expire|create_expire|synchronized|persistent|rotate_interval|rotate_size|encrypt|raw_output|mergeable|error_handler|type_column|deprecated)\b/
46 | },
47 | {
48 | token: "constant.language",
49 | regex: /\b(?:T|F)\b/
50 | },
51 | {
52 | token: "constant.numeric.port",
53 | regex: /\b\d{1,5}\/(?:udp|tcp|icmp|unknown)\b/
54 | },
55 | {
56 | token: "constant.numeric.addr",
57 | regex: /\b(?:25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[0-9]{1,2})\b/,
58 | comment: "IPv4 address"
59 | },
60 | {
61 | token: "constant.numeric.addr",
62 | regex: /\[(?:[0-9a-fA-F]{0,4}:){2,7}(?:[0-9a-fA-F]{0,4})?(?:(?:25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[0-9]{1,2})\.(?:25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[0-9]{1,2}))?\]/,
63 | comment: "IPv6 address"
64 | },
65 | {
66 | token: "constant.numeric.float.decimal.interval",
67 | regex: /(?:(?:\d*\.\d*(?:[eE][+-]?\d+)?|\d*[eE][+-]?\d+|\d*\.\d*)|\d+)\s*(?:day|hr|min|msec|usec|sec)s?/
68 | },
69 | {
70 | token: "constant.numeric.float.decimal",
71 | regex: /\d*\.\d*(?:[eE][+-]?\d+)?|\d*[eE][+-]?\d+|\d*\.\d*/
72 | },
73 | {
74 | token: "constant.numeric.hostname",
75 | regex: /\b[A-Za-z0-9][A-Za-z0-9\-]*(?:\.[A-Za-z0-9][A-Za-z0-9\-]*)+\b/
76 | },
77 | {
78 | token: "constant.numeric.integer.hexadecimal",
79 | regex: /\b0x[0-9a-fA-F]+\b/
80 | },
81 | {
82 | token: "constant.numeric.integer.decimal",
83 | regex: /\b\d+\b/
84 | },
85 | {
86 | token: "keyword.operator",
87 | regex: /==|!=|<=|<|>=|>/
88 | },
89 | {
90 | token: "keyword.operator",
91 | regex: /(&&)|(\|\|)|(!)/
92 | },
93 | {
94 | token: "keyword.operator",
95 | regex: /=|\+=|-=/
96 | },
97 | {
98 | token: "keyword.operator",
99 | regex: /\+\+|\+|--|-|\*|\/|%/
100 | },
101 | {
102 | token: "keyword.operator",
103 | regex: /&|\||\^|~/
104 | },
105 | {
106 | token: "keyword.operator",
107 | regex: /\b(?:in|as|is)\b/
108 | },
109 | {
110 | token: "punctuation.terminator",
111 | regex: /;/
112 | },
113 | {
114 | token: "punctuation.accessor",
115 | regex: /\??\$/
116 | },
117 | {
118 | token: "punctuation.accessor",
119 | regex: /::/
120 | },
121 | {
122 | token: "keyword.operator",
123 | regex: /\?/
124 | },
125 | // Unsure how to tell if colon is used as operator vs. separator.
126 | // {
127 | // token: "keyword.operator",
128 | // regex: /:/
129 | // },
130 | {
131 | token: "punctuation.separator",
132 | regex: /:/
133 | },
134 | {
135 | token: "punctuation.separator",
136 | regex: /,/
137 | },
138 | {
139 | token: [
140 | "keyword.other",
141 | "meta.namespace",
142 | "entity.name.namespace"
143 | ],
144 | regex: /(module)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)/
145 | },
146 | {
147 | token: "keyword.other",
148 | regex: /\bexport\b/
149 | },
150 | {
151 | token: "keyword.control.conditional",
152 | regex: /\b(?:if|else)\b/
153 | },
154 | {
155 | token: "keyword.control",
156 | regex: /\b(?:for|while)\b/
157 | },
158 | {
159 | token: "keyword.control",
160 | regex: /\b(?:return|break|next|continue|fallthrough)\b/
161 | },
162 | {
163 | token: "keyword.control",
164 | regex: /\b(?:switch|default|case)\b/
165 | },
166 | {
167 | token: "keyword.other",
168 | regex: /\b(?:add|delete)\b/
169 | },
170 | {
171 | token: "keyword.other",
172 | regex: /\bprint\b/
173 | },
174 | {
175 | token: "keyword.control",
176 | regex: /\b(?:when|timeout|schedule)\b/
177 | },
178 | {
179 | token: [
180 | "keyword.other",
181 | "meta.struct.record",
182 | "entity.name.struct.record",
183 | "meta.struct.record",
184 | "punctuation.separator",
185 | "meta.struct.record",
186 | "storage.type.struct.record"
187 | ],
188 | regex: /\b(type)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)(\s*)(:)(\s*\b)(record)\b/
189 | },
190 | {
191 | token: [
192 | "keyword.other",
193 | "meta.enum",
194 | "entity.name.enum",
195 | "meta.enum",
196 | "punctuation.separator",
197 | "meta.enum",
198 | "storage.type.enum"
199 | ],
200 | regex: /\b(type)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)(\s*)(:)(\s*\b)(enum)\b/
201 | },
202 | {
203 | token: [
204 | "keyword.other",
205 | "meta.type",
206 | "entity.name.type",
207 | "meta.type",
208 | "punctuation.separator"
209 | ],
210 | regex: /\b(type)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)(\s*)(:)/
211 | },
212 | {
213 | token: [
214 | "keyword.other",
215 | "meta.struct.record",
216 | "storage.type.struct.record",
217 | "meta.struct.record",
218 | "entity.name.struct.record"
219 | ],
220 | regex: /\b(redef)(\s+)(record)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)\b/
221 | },
222 | {
223 | token: [
224 | "keyword.other",
225 | "meta.enum",
226 | "storage.type.enum",
227 | "meta.enum",
228 | "entity.name.enum"
229 | ],
230 | regex: /\b(redef)(\s+)(enum)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)\b/
231 | },
232 | {
233 | token: [
234 | "storage.type",
235 | "text",
236 | "entity.name.function.event"
237 | ],
238 | regex: /\b(event)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)(?=s*\()/
239 | },
240 | {
241 | token: [
242 | "storage.type",
243 | "text",
244 | "entity.name.function.hook"
245 | ],
246 | regex: /\b(hook)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)(?=s*\()/
247 | },
248 | {
249 | token: [
250 | "storage.type",
251 | "text",
252 | "entity.name.function"
253 | ],
254 | regex: /\b(function)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)(?=s*\()/
255 | },
256 | {
257 | token: "keyword.other",
258 | regex: /\bredef\b/
259 | },
260 | {
261 | token: "storage.type",
262 | regex: /\bany\b/
263 | },
264 | {
265 | token: "storage.type",
266 | regex: /\b(?:enum|record|set|table|vector)\b/
267 | },
268 | {
269 | token: [
270 | "storage.type",
271 | "text",
272 | "keyword.operator",
273 | "text",
274 | "storage.type"
275 | ],
276 | regex: /\b(opaque)(\s+)(of)(\s+)([A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*)\b/
277 | },
278 | {
279 | token: "keyword.operator",
280 | regex: /\bof\b/
281 | },
282 | {
283 | token: "storage.type",
284 | regex: /\b(?:addr|bool|count|double|file|int|interval|pattern|port|string|subnet|time)\b/
285 | },
286 | {
287 | token: "storage.type",
288 | regex: /\b(?:function|hook|event)\b/
289 | },
290 | {
291 | token: "storage.modifier",
292 | regex: /\b(?:global|local|const|option)\b/
293 | },
294 | {
295 | token: "entity.name.function.call",
296 | regex: /\b[A-Za-z_][A-Za-z_0-9]*(?:::[A-Za-z_][A-Za-z_0-9]*)*(?=s*\()/
297 | },
298 | {
299 | token: "punctuation.section.block.begin",
300 | regex: /\{/
301 | },
302 | {
303 | token: "punctuation.section.block.end",
304 | regex: /\}/
305 | },
306 | {
307 | token: "punctuation.section.brackets.begin",
308 | regex: /\[/
309 | },
310 | {
311 | token: "punctuation.section.brackets.end",
312 | regex: /\]/
313 | },
314 | {
315 | token: "punctuation.section.parens.begin",
316 | regex: /\(/
317 | },
318 | {
319 | token: "punctuation.section.parens.end",
320 | regex: /\)/
321 | }
322 |
323 | ], // state: start
324 |
325 | "string-state": [
326 | {
327 | token: "constant.character.escape",
328 | regex: /\\./
329 | },
330 | {
331 | token: "string.double",
332 | regex: /"/,
333 | next: "start"
334 | },
335 | {
336 | token: "constant.other.placeholder",
337 | regex: /%-?[0-9]*(\.[0-9]+)?[DTdxsefg]/
338 | },
339 | {
340 | token: "string.double",
341 | regex: "."
342 | }
343 | ], // state: string-state
344 |
345 | "pattern-state": [
346 | {
347 | token: "constant.character.escape",
348 | regex: /\\./
349 | },
350 | {
351 | token: "string.regexp",
352 | regex: "/",
353 | next: "start"
354 | },
355 | {
356 | token: "string.regexp",
357 | regex: "."
358 | }
359 | ] // state: pattern-state
360 |
361 | };
362 |
363 | this.normalizeRules();
364 | };
365 |
366 | ZeekHighlightRules.metaData = {
367 | fileTypes: ["bro", "zeek"],
368 | name: "Zeek",
369 | scopeName: "source.zeek"
370 | };
371 |
372 | oop.inherits(ZeekHighlightRules, TextHighlightRules);
373 |
374 | exports.ZeekHighlightRules = ZeekHighlightRules;
375 | });
376 |
377 | ace.define('ace/mode/zeek', ['require', 'exports', 'module', 'ace/lib/oop', 'ace/mode/text', 'ace/mode/zeek_highlight_rules'], function(acequire, exports, module) {
378 |
379 | var oop = acequire("../lib/oop");
380 | var TextMode = acequire("./text").Mode;
381 | var ZeekHighlightRules = acequire("./zeek_highlight_rules").ZeekHighlightRules;
382 | var FoldMode = acequire("./folding/cstyle").FoldMode;
383 |
384 | var Mode = function() {
385 | this.HighlightRules = ZeekHighlightRules;
386 | this.foldingRules = new FoldMode();
387 | };
388 | oop.inherits(Mode, TextMode);
389 |
390 | (function() {
391 | this.lineCommentStart = "#";
392 | // Extra logic goes here.
393 | this.$id = "ace/mode/zeek";
394 | }).call(Mode.prototype);
395 |
396 | exports.Mode = Mode;
397 | });
398 |
--------------------------------------------------------------------------------
/manager/web-ui/src/App.css:
--------------------------------------------------------------------------------
1 | .Pointer {
2 | cursor: pointer;
3 | }
4 |
5 | .overflow{
6 | max-width:200px;
7 | white-space: nowrap;
8 | overflow: hidden;
9 | text-overflow: ellipsis;
10 | }
11 |
--------------------------------------------------------------------------------
/manager/web-ui/src/App.js:
--------------------------------------------------------------------------------
1 | import React, { Component } from 'react';
2 | import './App.css';
3 |
4 | import {connect} from 'react-redux';
5 |
6 | import brace from 'brace';
7 | import 'brace/theme/tomorrow';
8 |
9 | import AceEditor from 'react-ace';
10 | import ZeekMode from './ZeekMode.js'
11 |
12 | import { fetchVersions, setVersion } from './actions';
13 | import { fetchExamples, hideExample, showExample } from './actions';
14 | import { codeAddFile, codeSelectFile, codeRenameFile, codeEditFile } from './actions';
15 | import { execReset, execSubmit } from './actions';
16 | import { fetchPcaps, pcapSelected, pcapFileChanged } from './actions';
17 | import { formatSubmit } from './actions';
18 |
19 | import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
20 | import { solid, regular } from '@fortawesome/fontawesome-svg-core/import.macro' // <-- import styles to be used
21 |
22 | import {Tab, Tabs, Button, ButtonGroup} from 'react-bootstrap';
23 | import Pagination from 'react-bootstrap/Pagination';
24 | import Container from 'react-bootstrap/Container';
25 | import Row from 'react-bootstrap/Row';
26 | import Col from 'react-bootstrap/Col';
27 | import {Table} from 'react-bootstrap';
28 | import {Modal} from 'react-bootstrap';
29 |
30 | import { setHistoryToExample } from './tbhistory';
31 |
32 | var DropDown = ({options, includeBlank, selected, onChange}) => {
33 | if(includeBlank) {
34 | options = ['', ...options];
35 | }
36 | return (
37 |
42 | );
43 | };
44 |
45 |
46 | class BroVersions extends Component {
47 | change = v => this.props.onVersionChanged(v);
48 | render() {
49 | const { version, versions } = this.props.versions;
50 | return (
51 |
52 | Zeek Version
53 | { ' ' }
54 |
92 | this.handleSelect(e)} id="Editor">
93 | {this.props.code.sources.map(c =>
94 |
95 | {
104 | this.handleCodeChanged(c.name, contents)
105 | }}
106 | editorProps={{$blockScrolling: true}}
107 | setOptions={{useSoftTabs: false}}
108 | />
109 |
110 | )}
111 | Add
112 |
113 |
114 | )}
115 | }
116 |
117 | class BroExampleReadme extends Component {
118 | render() {
119 | const { example, onChange } = this.props;
120 | if (!example || !example.html) {
121 | return null;
122 | }
123 | var markup = {__html: example.html }
124 | var prev = example.prev ?
128 |
129 | {prev}
130 | {next}
131 |
132 |
133 |
134 | )
135 | }
136 | }
137 |
138 | var BroFileViewerDetailTable = ({record}) => {
139 | if (record == null)
140 | return null;
141 | return (
142 | | Field | 146 |Type | 147 |Value | 148 |
|---|---|---|
| {r[0]} | 154 |{r[1]} | 155 |{r[2]} | 156 |
| {h} | 209 | )} 210 |
|---|
{c} |
217 | )}
218 |
247 |
257 | )
258 | }
259 | }
260 |
261 | var BroFileViewerText = ({file}) => (
262 | {file}
263 | )
264 |
265 | var BroFileViewerDetail = ({file}) => {
266 | if(file.header) {
267 | return
285 |
287 | {Object.keys(files).map( (f) =>
288 |
289 |
291 | )}
292 |
293 |
294 | )
295 | }
296 | }
297 |
298 |
299 | var RunButton = ({status, pcap, onClick}) => {
300 | if (pcap.too_large)
301 | return ;
302 |
303 | if (pcap.uploading)
304 | return ;
305 |
306 | if (status)
307 | return ;
308 |
309 | return ;
310 | }
311 |
312 | var TextMessage = ({header, text, className}) => {
313 | if(!text) {
314 | return ;
315 | }
316 | return (
317 | Output Logs
286 |
318 |
321 | );
322 | }
323 |
324 | export class App extends Component {
325 | componentDidMount() {
326 | console.log('App mounted!');
327 | this.props.dispatch(fetchExamples());
328 | this.props.dispatch(fetchVersions());
329 | this.props.dispatch(fetchPcaps());
330 | }
331 | versionSelected = (version) => {
332 | this.props.dispatch(setVersion(version))
333 | }
334 | exampleSelected = (example) => {
335 | setHistoryToExample(example);
336 | this.props.dispatch(execReset())
337 | }
338 | hideExample = () => {
339 | this.props.dispatch(hideExample())
340 | }
341 | showExample = () => {
342 | this.props.dispatch(showExample())
343 | }
344 | addFile = () => {
345 | this.props.dispatch(codeAddFile());
346 | }
347 | renameFile = (new_name) => {
348 | this.props.dispatch(codeRenameFile(new_name));
349 | }
350 | selectFile = (name) => {
351 | this.props.dispatch(codeSelectFile(name));
352 | }
353 | codeChanged = (name, contents) => {
354 | this.props.dispatch(codeEditFile(name, contents));
355 | }
356 | pcapChanged = (pcap) => {
357 | this.refs.file.value=null;
358 | this.props.dispatch(pcapSelected(pcap));
359 | }
360 | runCode = () => {
361 | this.props.dispatch(execSubmit());
362 | }
363 | formatCode = () => {
364 | this.props.dispatch(formatSubmit());
365 | }
366 | fileChanged = () => {
367 | var f = this.refs.file.files[0];
368 | this.props.dispatch(pcapFileChanged(f));
369 | }
370 |
371 | renderLoadLine() {
372 | const { examples } = this.props;
373 | var showHide = null;
374 | if ( examples.example && examples.example.html && examples.hidden)
375 | showHide = ;
376 | else
377 | showHide = ;
378 |
379 | return (
380 | { header }
319 |{ text }
320 | 451 | {this.renderCodeRow()} 452 |