1 // Copyright 2015 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "src/inspector/v8-injected-script-host.h"
6 
7 #include "src/base/macros.h"
8 #include "src/inspector/injected-script-native.h"
9 #include "src/inspector/string-util.h"
10 #include "src/inspector/v8-debugger.h"
11 #include "src/inspector/v8-inspector-impl.h"
12 #include "src/inspector/v8-internal-value-type.h"
13 #include "src/inspector/v8-value-copier.h"
14 
15 #include "include/v8-inspector.h"
16 
17 namespace v8_inspector {
18 
19 namespace {
20 
setFunctionProperty(v8::Local<v8::Context> context,v8::Local<v8::Object> obj,const char * name,v8::FunctionCallback callback,v8::Local<v8::External> external)21 void setFunctionProperty(v8::Local<v8::Context> context,
22                          v8::Local<v8::Object> obj, const char* name,
23                          v8::FunctionCallback callback,
24                          v8::Local<v8::External> external) {
25   v8::Local<v8::String> funcName =
26       toV8StringInternalized(context->GetIsolate(), name);
27   v8::Local<v8::Function> func;
28   if (!v8::Function::New(context, callback, external, 0,
29                          v8::ConstructorBehavior::kThrow)
30            .ToLocal(&func))
31     return;
32   func->SetName(funcName);
33   createDataProperty(context, obj, funcName, func);
34 }
35 
unwrapInspector(const v8::FunctionCallbackInfo<v8::Value> & info)36 V8InspectorImpl* unwrapInspector(
37     const v8::FunctionCallbackInfo<v8::Value>& info) {
38   DCHECK(!info.Data().IsEmpty());
39   DCHECK(info.Data()->IsExternal());
40   V8InspectorImpl* inspector =
41       static_cast<V8InspectorImpl*>(info.Data().As<v8::External>()->Value());
42   DCHECK(inspector);
43   return inspector;
44 }
45 
46 }  // namespace
47 
create(v8::Local<v8::Context> context,V8InspectorImpl * inspector)48 v8::Local<v8::Object> V8InjectedScriptHost::create(
49     v8::Local<v8::Context> context, V8InspectorImpl* inspector) {
50   v8::Isolate* isolate = inspector->isolate();
51   v8::Local<v8::Object> injectedScriptHost = v8::Object::New(isolate);
52   bool success = injectedScriptHost->SetPrototype(context, v8::Null(isolate))
53                      .FromMaybe(false);
54   DCHECK(success);
55   USE(success);
56   v8::Local<v8::External> debuggerExternal =
57       v8::External::New(isolate, inspector);
58   setFunctionProperty(context, injectedScriptHost, "internalConstructorName",
59                       V8InjectedScriptHost::internalConstructorNameCallback,
60                       debuggerExternal);
61   setFunctionProperty(
62       context, injectedScriptHost, "formatAccessorsAsProperties",
63       V8InjectedScriptHost::formatAccessorsAsProperties, debuggerExternal);
64   setFunctionProperty(context, injectedScriptHost, "subtype",
65                       V8InjectedScriptHost::subtypeCallback, debuggerExternal);
66   setFunctionProperty(context, injectedScriptHost, "getInternalProperties",
67                       V8InjectedScriptHost::getInternalPropertiesCallback,
68                       debuggerExternal);
69   setFunctionProperty(context, injectedScriptHost, "objectHasOwnProperty",
70                       V8InjectedScriptHost::objectHasOwnPropertyCallback,
71                       debuggerExternal);
72   setFunctionProperty(context, injectedScriptHost, "bind",
73                       V8InjectedScriptHost::bindCallback, debuggerExternal);
74   setFunctionProperty(context, injectedScriptHost, "proxyTargetValue",
75                       V8InjectedScriptHost::proxyTargetValueCallback,
76                       debuggerExternal);
77   return injectedScriptHost;
78 }
79 
internalConstructorNameCallback(const v8::FunctionCallbackInfo<v8::Value> & info)80 void V8InjectedScriptHost::internalConstructorNameCallback(
81     const v8::FunctionCallbackInfo<v8::Value>& info) {
82   if (info.Length() < 1 || !info[0]->IsObject()) return;
83 
84   v8::Local<v8::Object> object = info[0].As<v8::Object>();
85   info.GetReturnValue().Set(object->GetConstructorName());
86 }
87 
formatAccessorsAsProperties(const v8::FunctionCallbackInfo<v8::Value> & info)88 void V8InjectedScriptHost::formatAccessorsAsProperties(
89     const v8::FunctionCallbackInfo<v8::Value>& info) {
90   DCHECK_EQ(info.Length(), 2);
91   info.GetReturnValue().Set(false);
92   if (!info[1]->IsFunction()) return;
93   // Check that function is user-defined.
94   if (info[1].As<v8::Function>()->ScriptId() != v8::UnboundScript::kNoScriptId)
95     return;
96   info.GetReturnValue().Set(
97       unwrapInspector(info)->client()->formatAccessorsAsProperties(info[0]));
98 }
99 
subtypeCallback(const v8::FunctionCallbackInfo<v8::Value> & info)100 void V8InjectedScriptHost::subtypeCallback(
101     const v8::FunctionCallbackInfo<v8::Value>& info) {
102   if (info.Length() < 1) return;
103 
104   v8::Isolate* isolate = info.GetIsolate();
105   v8::Local<v8::Value> value = info[0];
106   if (value->IsObject()) {
107     v8::Local<v8::Value> internalType = v8InternalValueTypeFrom(
108         isolate->GetCurrentContext(), v8::Local<v8::Object>::Cast(value));
109     if (internalType->IsString()) {
110       info.GetReturnValue().Set(internalType);
111       return;
112     }
113   }
114   if (value->IsArray() || value->IsArgumentsObject()) {
115     info.GetReturnValue().Set(toV8StringInternalized(isolate, "array"));
116     return;
117   }
118   if (value->IsTypedArray()) {
119     info.GetReturnValue().Set(toV8StringInternalized(isolate, "typedarray"));
120     return;
121   }
122   if (value->IsDate()) {
123     info.GetReturnValue().Set(toV8StringInternalized(isolate, "date"));
124     return;
125   }
126   if (value->IsRegExp()) {
127     info.GetReturnValue().Set(toV8StringInternalized(isolate, "regexp"));
128     return;
129   }
130   if (value->IsMap() || value->IsWeakMap()) {
131     info.GetReturnValue().Set(toV8StringInternalized(isolate, "map"));
132     return;
133   }
134   if (value->IsSet() || value->IsWeakSet()) {
135     info.GetReturnValue().Set(toV8StringInternalized(isolate, "set"));
136     return;
137   }
138   if (value->IsMapIterator() || value->IsSetIterator()) {
139     info.GetReturnValue().Set(toV8StringInternalized(isolate, "iterator"));
140     return;
141   }
142   if (value->IsGeneratorObject()) {
143     info.GetReturnValue().Set(toV8StringInternalized(isolate, "generator"));
144     return;
145   }
146   if (value->IsNativeError()) {
147     info.GetReturnValue().Set(toV8StringInternalized(isolate, "error"));
148     return;
149   }
150   if (value->IsProxy()) {
151     info.GetReturnValue().Set(toV8StringInternalized(isolate, "proxy"));
152     return;
153   }
154   if (value->IsPromise()) {
155     info.GetReturnValue().Set(toV8StringInternalized(isolate, "promise"));
156     return;
157   }
158   std::unique_ptr<StringBuffer> subtype =
159       unwrapInspector(info)->client()->valueSubtype(value);
160   if (subtype) {
161     info.GetReturnValue().Set(toV8String(isolate, subtype->string()));
162     return;
163   }
164 }
165 
getInternalPropertiesCallback(const v8::FunctionCallbackInfo<v8::Value> & info)166 void V8InjectedScriptHost::getInternalPropertiesCallback(
167     const v8::FunctionCallbackInfo<v8::Value>& info) {
168   if (info.Length() < 1) return;
169 
170   std::unordered_set<String16> allowedProperties;
171   if (info[0]->IsBooleanObject() || info[0]->IsNumberObject() ||
172       info[0]->IsStringObject() || info[0]->IsSymbolObject()) {
173     allowedProperties.insert(String16("[[PrimitiveValue]]"));
174   } else if (info[0]->IsPromise()) {
175     allowedProperties.insert(String16("[[PromiseStatus]]"));
176     allowedProperties.insert(String16("[[PromiseValue]]"));
177   } else if (info[0]->IsGeneratorObject()) {
178     allowedProperties.insert(String16("[[GeneratorStatus]]"));
179   } else if (info[0]->IsMapIterator() || info[0]->IsSetIterator()) {
180     allowedProperties.insert(String16("[[IteratorHasMore]]"));
181     allowedProperties.insert(String16("[[IteratorIndex]]"));
182     allowedProperties.insert(String16("[[IteratorKind]]"));
183     allowedProperties.insert(String16("[[Entries]]"));
184   } else if (info[0]->IsMap() || info[0]->IsWeakMap() || info[0]->IsSet() ||
185              info[0]->IsWeakSet()) {
186     allowedProperties.insert(String16("[[Entries]]"));
187   }
188   if (!allowedProperties.size()) return;
189 
190   v8::Isolate* isolate = info.GetIsolate();
191   v8::Local<v8::Array> allProperties;
192   if (!unwrapInspector(info)
193            ->debugger()
194            ->internalProperties(isolate->GetCurrentContext(), info[0])
195            .ToLocal(&allProperties) ||
196       !allProperties->IsArray() || allProperties->Length() % 2 != 0)
197     return;
198 
199   {
200     v8::Local<v8::Context> context = isolate->GetCurrentContext();
201     v8::TryCatch tryCatch(isolate);
202     v8::Isolate::DisallowJavascriptExecutionScope throwJs(
203         isolate,
204         v8::Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE);
205 
206     v8::Local<v8::Array> properties = v8::Array::New(isolate);
207     if (tryCatch.HasCaught()) return;
208 
209     uint32_t outputIndex = 0;
210     for (uint32_t i = 0; i < allProperties->Length(); i += 2) {
211       v8::Local<v8::Value> key;
212       if (!allProperties->Get(context, i).ToLocal(&key)) continue;
213       if (tryCatch.HasCaught()) {
214         tryCatch.Reset();
215         continue;
216       }
217       String16 keyString = toProtocolStringWithTypeCheck(key);
218       if (keyString.isEmpty() ||
219           allowedProperties.find(keyString) == allowedProperties.end())
220         continue;
221       v8::Local<v8::Value> value;
222       if (!allProperties->Get(context, i + 1).ToLocal(&value)) continue;
223       if (tryCatch.HasCaught()) {
224         tryCatch.Reset();
225         continue;
226       }
227       createDataProperty(context, properties, outputIndex++, key);
228       createDataProperty(context, properties, outputIndex++, value);
229     }
230     info.GetReturnValue().Set(properties);
231   }
232 }
233 
objectHasOwnPropertyCallback(const v8::FunctionCallbackInfo<v8::Value> & info)234 void V8InjectedScriptHost::objectHasOwnPropertyCallback(
235     const v8::FunctionCallbackInfo<v8::Value>& info) {
236   if (info.Length() < 2 || !info[0]->IsObject() || !info[1]->IsString()) return;
237   bool result = info[0]
238                     .As<v8::Object>()
239                     ->HasOwnProperty(info.GetIsolate()->GetCurrentContext(),
240                                      v8::Local<v8::String>::Cast(info[1]))
241                     .FromMaybe(false);
242   info.GetReturnValue().Set(v8::Boolean::New(info.GetIsolate(), result));
243 }
244 
bindCallback(const v8::FunctionCallbackInfo<v8::Value> & info)245 void V8InjectedScriptHost::bindCallback(
246     const v8::FunctionCallbackInfo<v8::Value>& info) {
247   if (info.Length() < 2 || !info[1]->IsString()) return;
248   InjectedScriptNative* injectedScriptNative =
249       InjectedScriptNative::fromInjectedScriptHost(info.GetIsolate(),
250                                                    info.Holder());
251   if (!injectedScriptNative) return;
252 
253   v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
254   v8::Local<v8::String> v8groupName =
255       info[1]->ToString(context).ToLocalChecked();
256   String16 groupName = toProtocolStringWithTypeCheck(v8groupName);
257   int id = injectedScriptNative->bind(info[0], groupName);
258   info.GetReturnValue().Set(id);
259 }
260 
proxyTargetValueCallback(const v8::FunctionCallbackInfo<v8::Value> & info)261 void V8InjectedScriptHost::proxyTargetValueCallback(
262     const v8::FunctionCallbackInfo<v8::Value>& info) {
263   if (info.Length() != 1 || !info[0]->IsProxy()) {
264     UNREACHABLE();
265     return;
266   }
267   v8::Local<v8::Object> target = info[0].As<v8::Proxy>();
268   while (target->IsProxy())
269     target = v8::Local<v8::Proxy>::Cast(target)->GetTarget();
270   info.GetReturnValue().Set(target);
271 }
272 
273 }  // namespace v8_inspector
274